Commit 08f4ce3

@@ -37,47 +37,47 @@
     </Reference>
     <Reference Include="bdddoc, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\test\bdd.doc\bdddoc.dll</HintPath>
+      <HintPath>..\..\..\build\lib\test\bdd.doc\bdddoc.dll</HintPath>
     </Reference>
     <Reference Include="Castle.Core, Version=1.0.3.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\app\castle\Castle.Core.dll</HintPath>
+      <HintPath>..\..\..\build\lib\app\castle\Castle.Core.dll</HintPath>
     </Reference>
     <Reference Include="developwithpassion.bdd, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\test\developwithpassion\developwithpassion.bdd.dll</HintPath>
+      <HintPath>..\..\..\build\lib\test\developwithpassion\developwithpassion.bdd.dll</HintPath>
     </Reference>
     <Reference Include="gorilla.commons.infrastructure, Version=2009.10.21.739, Culture=neutral, PublicKeyToken=687787ccb6c36c9f, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\app\gorilla\gorilla.commons.infrastructure.dll</HintPath>
+      <HintPath>..\..\..\build\lib\app\gorilla\gorilla.commons.infrastructure.dll</HintPath>
     </Reference>
     <Reference Include="gorilla.commons.infrastructure.thirdparty, Version=2009.10.21.739, Culture=neutral, PublicKeyToken=687787ccb6c36c9f, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\app\gorilla\gorilla.commons.infrastructure.thirdparty.dll</HintPath>
+      <HintPath>..\..\..\build\lib\app\gorilla\gorilla.commons.infrastructure.thirdparty.dll</HintPath>
     </Reference>
     <Reference Include="gorilla.commons.infrastructure.thirdparty.log4net, Version=2009.10.21.739, Culture=neutral, PublicKeyToken=687787ccb6c36c9f, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\app\gorilla\gorilla.commons.infrastructure.thirdparty.log4net.dll</HintPath>
+      <HintPath>..\..\..\build\lib\app\gorilla\gorilla.commons.infrastructure.thirdparty.log4net.dll</HintPath>
     </Reference>
     <Reference Include="gorilla.commons.utility, Version=2009.10.21.739, Culture=neutral, PublicKeyToken=687787ccb6c36c9f, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\app\gorilla\gorilla.commons.utility.dll</HintPath>
+      <HintPath>..\..\..\build\lib\app\gorilla\gorilla.commons.utility.dll</HintPath>
     </Reference>
     <Reference Include="gorilla.testing, Version=2009.5.5.194, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\test\gorilla\gorilla.testing.dll</HintPath>
+      <HintPath>..\..\..\build\lib\test\gorilla\gorilla.testing.dll</HintPath>
     </Reference>
     <Reference Include="JetBrains.Annotations, Version=4.1.933.3, Culture=neutral, PublicKeyToken=1010a0d8d6380325, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\app\jetbrains\JetBrains.Annotations.dll</HintPath>
+      <HintPath>..\..\..\build\lib\app\jetbrains\JetBrains.Annotations.dll</HintPath>
     </Reference>
     <Reference Include="log4net, Version=1.2.10.0, Culture=neutral, PublicKeyToken=1b44e1d426115821, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\app\log4net\log4net.dll</HintPath>
+      <HintPath>..\..\..\build\lib\app\log4net\log4net.dll</HintPath>
     </Reference>
     <Reference Include="MbUnit.Framework, Version=2.4.2.130, Culture=neutral, PublicKeyToken=5e72ecd30bc408d5">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\tools\mbunit\MbUnit.Framework.dll</HintPath>
+      <HintPath>..\..\..\build\tools\mbunit\MbUnit.Framework.dll</HintPath>
     </Reference>
     <Reference Include="PresentationCore">
       <RequiredTargetFramework>3.0</RequiredTargetFramework>
@@ -87,12 +87,12 @@
     </Reference>
     <Reference Include="Rhino.Mocks, Version=3.5.0.1337, Culture=neutral, PublicKeyToken=0b3305902db7183f, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\test\rhino.mocks\Rhino.Mocks.dll</HintPath>
+      <HintPath>..\..\..\build\lib\test\rhino.mocks\Rhino.Mocks.dll</HintPath>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.ComponentModel.Composition, Version=2008.11.24.0, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\app\managed.extensibility.framework\System.ComponentModel.Composition.dll</HintPath>
+      <HintPath>..\..\..\build\lib\app\managed.extensibility.framework\System.ComponentModel.Composition.dll</HintPath>
     </Reference>
     <Reference Include="System.Core">
       <RequiredTargetFramework>3.5</RequiredTargetFramework>
@@ -111,7 +111,7 @@
     </Reference>
     <Reference Include="WeifenLuo.WinFormsUI.Docking, Version=2.3.3392.19652, Culture=neutral, PublicKeyToken=b602bcfb76b4e90d, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\app\dock.panel.suite\WeifenLuo.WinFormsUI.Docking.dll</HintPath>
+      <HintPath>..\..\..\build\lib\app\dock.panel.suite\WeifenLuo.WinFormsUI.Docking.dll</HintPath>
     </Reference>
   </ItemGroup>
   <ItemGroup>
@@ -239,4 +239,4 @@
   <Target Name="AfterBuild">
   </Target>
   -->
-</Project>
\ No newline at end of file
+</Project>

@@ -1,7 +1,6 @@
 using System;
 using System.ComponentModel;
 using System.Linq;
-using Gorilla.Commons.Infrastructure.Logging;
 using gorilla.commons.utility;
 using momoney.presentation.views;
 

@@ -37,39 +37,39 @@
     </Reference>
     <Reference Include="ActiveReports.Viewer6, Version=6.0.1797.0, Culture=neutral, PublicKeyToken=cc4967777c49a3ff, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\app\active.reports\ActiveReports.Viewer6.dll</HintPath>
+      <HintPath>..\..\..\build\lib\app\active.reports\ActiveReports.Viewer6.dll</HintPath>
     </Reference>
     <Reference Include="ActiveReports6, Version=6.0.1797.0, Culture=neutral, PublicKeyToken=cc4967777c49a3ff, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\app\active.reports\ActiveReports6.dll</HintPath>
+      <HintPath>..\..\..\build\lib\app\active.reports\ActiveReports6.dll</HintPath>
     </Reference>
     <Reference Include="bdddoc, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\test\bdd.doc\bdddoc.dll</HintPath>
+      <HintPath>..\..\..\build\lib\test\bdd.doc\bdddoc.dll</HintPath>
     </Reference>
     <Reference Include="ComponentFactory.Krypton.Toolkit, Version=3.0.8.0, Culture=neutral, PublicKeyToken=a87e673e9ecb6e8e, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\app\component.factory\ComponentFactory.Krypton.Toolkit.dll</HintPath>
+      <HintPath>..\..\..\build\lib\app\component.factory\ComponentFactory.Krypton.Toolkit.dll</HintPath>
     </Reference>
     <Reference Include="developwithpassion.bdd, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\test\developwithpassion\developwithpassion.bdd.dll</HintPath>
+      <HintPath>..\..\..\build\lib\test\developwithpassion\developwithpassion.bdd.dll</HintPath>
     </Reference>
     <Reference Include="gorilla.commons.infrastructure, Version=2009.5.5.1633, Culture=neutral, PublicKeyToken=687787ccb6c36c9f, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\app\gorilla\gorilla.commons.infrastructure.dll</HintPath>
+      <HintPath>..\..\..\build\lib\app\gorilla\gorilla.commons.infrastructure.dll</HintPath>
     </Reference>
     <Reference Include="gorilla.commons.utility, Version=2009.5.5.1633, Culture=neutral, PublicKeyToken=687787ccb6c36c9f, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\app\gorilla\gorilla.commons.utility.dll</HintPath>
+      <HintPath>..\..\..\build\lib\app\gorilla\gorilla.commons.utility.dll</HintPath>
     </Reference>
     <Reference Include="gorilla.testing, Version=2009.5.5.194, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\test\gorilla\gorilla.testing.dll</HintPath>
+      <HintPath>..\..\..\build\lib\test\gorilla\gorilla.testing.dll</HintPath>
     </Reference>
     <Reference Include="MbUnit.Framework, Version=2.4.2.175, Culture=neutral, PublicKeyToken=5e72ecd30bc408d5">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\test\mbunit\MbUnit.Framework.dll</HintPath>
+      <HintPath>..\..\..\build\lib\test\mbunit\MbUnit.Framework.dll</HintPath>
     </Reference>
     <Reference Include="PresentationCore">
       <RequiredTargetFramework>3.0</RequiredTargetFramework>
@@ -79,12 +79,12 @@
     </Reference>
     <Reference Include="Rhino.Mocks, Version=3.5.0.1337, Culture=neutral, PublicKeyToken=0b3305902db7183f, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\test\rhino.mocks\Rhino.Mocks.dll</HintPath>
+      <HintPath>..\..\..\build\lib\test\rhino.mocks\Rhino.Mocks.dll</HintPath>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.ComponentModel.Composition, Version=2009.1.23.0, Culture=neutral, PublicKeyToken=687787ccb6c36c9f, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\app\managed.extensibility.framework\System.ComponentModel.Composition.dll</HintPath>
+      <HintPath>..\..\..\build\lib\app\managed.extensibility.framework\System.ComponentModel.Composition.dll</HintPath>
     </Reference>
     <Reference Include="System.Core">
       <RequiredTargetFramework>3.5</RequiredTargetFramework>
@@ -104,14 +104,14 @@
     </Reference>
     <Reference Include="WeifenLuo.WinFormsUI.Docking, Version=2.3.3392.19652, Culture=neutral, PublicKeyToken=b602bcfb76b4e90d, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\app\dock.panel.suite\WeifenLuo.WinFormsUI.Docking.dll</HintPath>
+      <HintPath>..\..\..\build\lib\app\dock.panel.suite\WeifenLuo.WinFormsUI.Docking.dll</HintPath>
     </Reference>
     <Reference Include="WindowsBase">
       <RequiredTargetFramework>3.0</RequiredTargetFramework>
     </Reference>
     <Reference Include="XPExplorerBar, Version=3.3.0.0, Culture=neutral, PublicKeyToken=26272737b5f33015">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\build\lib\app\xp.explorer.bar\XPExplorerBar.dll</HintPath>
+      <HintPath>..\..\..\build\lib\app\xp.explorer.bar\XPExplorerBar.dll</HintPath>
     </Reference>
   </ItemGroup>
   <ItemGroup>
@@ -569,4 +569,4 @@
   <Target Name="AfterBuild">
   </Target>
   -->
-</Project>
\ No newline at end of file
+</Project>

@@ -0,0 +1,11 @@
+using System.Runtime.Serialization.Formatters.Binary;
+
+namespace Gorilla.Commons.Infrastructure.Cloning
+{
+    public class BinarySerializer<T> : FileStreamSerializer<T>
+    {
+        public BinarySerializer(string file_path) : base(file_path, new BinaryFormatter())
+        {
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,74 @@
+using System;
+using System.IO;
+using developwithpassion.bdd.contexts;
+using Gorilla.Commons.Testing;
+using MbUnit.Framework;
+
+namespace Gorilla.Commons.Infrastructure.Cloning
+{
+    [Concern(typeof (BinarySerializer<TestItem>))]
+    public abstract class when_a_file_is_specified_to_serialize_an_item_to : concerns_for<Serializer<TestItem>, BinarySerializer<TestItem>>
+    {
+        public override Serializer<TestItem> create_sut()
+        {
+            return new BinarySerializer<TestItem>(file_name);
+        }
+
+        context c = () => { file_name = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "serialized.dat"); };
+
+        after_each_observation aeo = () => { if (File.Exists(file_name)) File.Delete(file_name); };
+
+        static protected string file_name;
+    }
+
+    [Concern(typeof (BinarySerializer<TestItem>))]
+    public class when_serializing_an_item : when_a_file_is_specified_to_serialize_an_item_to
+    {
+        it should_serialize_the_item_to_a_file = () => FileAssert.Exists(file_name);
+
+        because b = () => sut.serialize(new TestItem(string.Empty));
+    }
+
+    [Concern(typeof (BinarySerializer<TestItem>))]
+    public class when_deserializing_an_item : when_a_file_is_specified_to_serialize_an_item_to
+    {
+        it should_be_able_to_deserialize_from_a_serialized_file = () => result.should_be_equal_to(original);
+
+        context c = () => { original = new TestItem("hello world"); };
+
+        because b = () =>
+                        {
+                            sut.serialize(original);
+                            result = sut.deserialize();
+                        };
+
+        static TestItem original;
+        static TestItem result;
+    }
+
+    [Serializable]
+    public class TestItem : IEquatable<TestItem>
+    {
+        public TestItem(string text)
+        {
+            Text = text;
+        }
+
+        public string Text { get; set; }
+
+        public bool Equals(TestItem testItem)
+        {
+            return testItem != null;
+        }
+
+        public override bool Equals(object obj)
+        {
+            return ReferenceEquals(this, obj) || Equals(obj as TestItem);
+        }
+
+        public override int GetHashCode()
+        {
+            return 0;
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,34 @@
+using System.IO;
+using System.Runtime.Serialization;
+
+namespace Gorilla.Commons.Infrastructure.Cloning
+{
+    public class FileStreamSerializer<T> : Serializer<T>
+    {
+        public FileStreamSerializer(string file_path, IFormatter formatter)
+        {
+            this.file_path = file_path;
+            this.formatter = formatter;
+        }
+
+        public void serialize(T to_serialize)
+        {
+            using (var stream = new FileStream(file_path, FileMode.Create, FileAccess.Write))
+                formatter.Serialize(stream, to_serialize);
+        }
+
+        public T deserialize()
+        {
+            using (var stream = new FileStream(file_path, FileMode.Open, FileAccess.Read))
+                return (T) formatter.Deserialize(stream);
+        }
+
+        public void Dispose()
+        {
+            File.Delete(file_path);
+        }
+
+        readonly string file_path;
+        readonly IFormatter formatter;
+    }
+}
\ No newline at end of file

@@ -0,0 +1,21 @@
+using System.IO;
+
+namespace Gorilla.Commons.Infrastructure.Cloning
+{
+    public interface IPrototype
+    {
+        T clone<T>(T item);
+    }
+
+    public class Prototype : IPrototype
+    {
+        public T clone<T>(T item)
+        {
+            using (var serializer = new BinarySerializer<T>(Path.GetTempFileName()))
+            {
+                serializer.serialize(item);
+                return serializer.deserialize();
+            }
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,10 @@
+using System;
+
+namespace Gorilla.Commons.Infrastructure.Cloning
+{
+    public interface Serializer<T> : IDisposable
+    {
+        void serialize(T to_serialize);
+        T deserialize();
+    }
+}
\ No newline at end of file

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace Gorilla.Commons.Infrastructure.Container
+{
+    public interface DependencyRegistry
+    {
+        Contract get_a<Contract>();
+        IEnumerable<Contract> get_all<Contract>();
+    }
+}
\ No newline at end of file

@@ -0,0 +1,13 @@
+using System;
+using gorilla.commons.utility;
+
+namespace Gorilla.Commons.Infrastructure.Container
+{
+    public class DependencyResolutionException<T> : Exception
+    {
+        public DependencyResolutionException(Exception inner_exception)
+            : base("Could not resolve {0}".formatted_using(typeof (T).FullName), inner_exception)
+        {
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,33 @@
+using System;
+
+namespace Gorilla.Commons.Infrastructure.Container
+{
+    static public class Resolve
+    {
+        static DependencyRegistry underlying_registry;
+        static bool initialized;
+
+        static public void initialize_with(DependencyRegistry registry)
+        {
+            underlying_registry = registry;
+            initialized = registry != null;
+        }
+
+        static public DependencyToResolve the<DependencyToResolve>()
+        {
+            try
+            {
+                return underlying_registry.get_a<DependencyToResolve>();
+            }
+            catch (Exception e)
+            {
+                throw new DependencyResolutionException<DependencyToResolve>(e);
+            }
+        }
+
+        static public bool is_initialized()
+        {
+            return initialized;
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,58 @@
+using System;
+using developwithpassion.bdd.contexts;
+using Gorilla.Commons.Testing;
+using gorilla.commons.utility;
+
+namespace Gorilla.Commons.Infrastructure.Container
+{
+    [Concern(typeof (Resolve))]
+    public abstract class behaves_like_a_inversion_of_control_container : concerns
+    {
+    }
+
+    [Concern(typeof(Resolve))]
+    public class when_resolving_a_dependency_using_the_container : behaves_like_a_inversion_of_control_container
+    {
+        context c = () =>
+                        {
+                            registry = an<DependencyRegistry>();
+                            presenter = an<Command>();
+                            registry.is_told_to(x => x.get_a<Command>()).it_will_return(presenter);
+                            Resolve.initialize_with(registry);
+                        };
+
+        because b = () => { result = Resolve.the<Command>(); };
+
+        it should_leverage_the_underlying_container_it_was_initialized_with =
+            () => registry.was_told_to(x => x.get_a<Command>());
+
+        it should_return_the_resolved_dependency = () => result.should_be_equal_to(presenter);
+
+        after_each_observation a = () => Resolve.initialize_with(null);
+
+        static DependencyRegistry registry;
+        static Command result;
+        static Command presenter;
+    }
+
+    [Concern(typeof(Resolve))]
+    public class when_resolving_a_dependency_that_is_not_registered_ : behaves_like_a_inversion_of_control_container
+    {
+        context c = () =>
+                        {
+                            registry = an<DependencyRegistry>();
+                            registry.is_told_to(x => x.get_a<Command>()).it_will_throw(new Exception());
+                            Resolve.initialize_with(registry);
+                        };
+
+        because b = () => { the_call = call.to(() => Resolve.the<Command>()); };
+
+        after_each_observation a = () => Resolve.initialize_with(null);
+
+        it should_throw_a_dependency_resolution_exception =
+            () => the_call.should_have_thrown<DependencyResolutionException<Command>>();
+
+        static DependencyRegistry registry;
+        static Action the_call;
+    }
+}
\ No newline at end of file

@@ -0,0 +1,15 @@
+using System.Diagnostics;
+
+namespace Gorilla.Commons.Infrastructure.Debugging
+{
+    static public class Launch
+    {
+        static public void the_debugger()
+        {
+#if DEBUG
+            if (Debugger.IsAttached) Debugger.Break();
+            else Debugger.Launch();
+#endif
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,62 @@
+namespace Gorilla.Commons.Infrastructure.FileSystem
+{
+    public class ApplicationFile : File
+    {
+        public ApplicationFile(string path)
+        {
+            this.path = path;
+        }
+
+        public virtual string path { get; private set; }
+
+        public virtual bool does_the_file_exist()
+        {
+            return !string.IsNullOrEmpty(path) && System.IO.File.Exists(path);
+        }
+
+        public void copy_to(string other_path)
+        {
+            System.IO.File.Copy(path, other_path, true);
+        }
+
+        public void delete()
+        {
+            System.IO.File.Delete(path);
+        }
+
+        public static implicit operator ApplicationFile(string file_path)
+        {
+            return new ApplicationFile(file_path);
+        }
+
+        public static implicit operator string(ApplicationFile file)
+        {
+            return file.path;
+        }
+
+        public bool Equals(ApplicationFile other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+            return Equals(other.path, path);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != typeof (ApplicationFile)) return false;
+            return Equals((ApplicationFile) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return (path != null ? path.GetHashCode() : 0);
+        }
+
+        public override string ToString()
+        {
+            return path;
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,10 @@
+namespace Gorilla.Commons.Infrastructure.FileSystem
+{
+    public interface File
+    {
+        string path { get; }
+        bool does_the_file_exist();
+        void copy_to(string path);
+        void delete();
+    }
+}
\ No newline at end of file

@@ -0,0 +1,25 @@
+using System;
+using Gorilla.Commons.Infrastructure.Container;
+
+namespace Gorilla.Commons.Infrastructure.Logging
+{
+    static public class Log
+    {
+        static public Logger For<T>(T item_to_create_logger_for)
+        {
+            return For(typeof (T));
+        }
+
+        static public Logger For(Type type_to_create_a_logger_for)
+        {
+            try
+            {
+                return Resolve.the<LogFactory>().create_for(type_to_create_a_logger_for);
+            }
+            catch
+            {
+                return new TextLogger(Console.Out);
+            }
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,9 @@
+using System;
+
+namespace Gorilla.Commons.Infrastructure.Logging
+{
+    public interface LogFactory
+    {
+        Logger create_for(Type type_to_create_logger_for);
+    }
+}
\ No newline at end of file

@@ -0,0 +1,7 @@
+namespace Gorilla.Commons.Infrastructure.Logging
+{
+    public interface Loggable
+    {
+        
+    }
+}
\ No newline at end of file

@@ -0,0 +1,11 @@
+using System;
+
+namespace Gorilla.Commons.Infrastructure.Logging
+{
+    public interface Logger
+    {
+        void informational(string formatted_string, params object[] arguments);
+        void debug(string formatted_string, params object[] arguments);
+        void error(Exception e);
+    }
+}
\ No newline at end of file

@@ -0,0 +1,17 @@
+using System;
+
+namespace Gorilla.Commons.Infrastructure.Logging
+{
+    public static class LoggingExtensions
+    {
+        public static Logger log<T>(this T item_to_log)
+        {
+            return Log.For(item_to_log);
+        }
+
+        public static void add_to_log(this Exception error_to_log)
+        {
+            Log.For(error_to_log).error(error_to_log);
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,31 @@
+using developwithpassion.bdd.contexts;
+using Gorilla.Commons.Infrastructure.Container;
+using Gorilla.Commons.Testing;
+
+namespace Gorilla.Commons.Infrastructure.Logging
+{
+    [Concern(typeof (Log))]
+    public class when_creating_a_logger_for_a_particular_type_ : concerns
+    {
+        it should_return_the_logger_created_for_that_type = () => result.should_be_equal_to(logger);
+
+        context c =
+            () =>
+                {
+                    var factory = an<LogFactory>();
+                    var registry = an<DependencyRegistry>();
+                    logger = an<Logger>();
+                    registry.is_told_to(x => x.get_a<LogFactory>()).it_will_return(factory);
+                    factory.is_told_to(x => x.create_for(typeof (string))).it_will_return(logger);
+
+                    Resolve.initialize_with(registry);
+                };
+
+        because b = () => { result = Log.For("mo"); };
+
+        after_each_observation a = () => Resolve.initialize_with(null);
+
+        static Logger result;
+        static Logger logger;
+    }
+}
\ No newline at end of file

@@ -0,0 +1,33 @@
+using System;
+using System.IO;
+using System.Threading;
+using gorilla.commons.utility;
+
+namespace Gorilla.Commons.Infrastructure.Logging
+{
+    public class TextLogger : Logger
+    {
+        readonly TextWriter writer;
+
+        public TextLogger(TextWriter writer)
+        {
+            this.writer = writer;
+        }
+
+        public void informational(string formatted_string, params object[] arguments)
+        {
+            writer.WriteLine(formatted_string, arguments);
+        }
+
+        public void debug(string formatted_string, params object[] arguments)
+        {
+            writer.WriteLine("[{0}] - {1}", Thread.CurrentThread.ManagedThreadId,
+                             formatted_string.formatted_using(arguments));
+        }
+
+        public void error(Exception e)
+        {
+            writer.WriteLine("{0}", e);
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,18 @@
+using System;
+using System.Reflection;
+
+namespace Gorilla.Commons.Infrastructure.Proxies
+{
+    static public class ExceptionExtensions
+    {
+        static readonly MethodInfo method =
+            typeof (Exception).GetMethod("InternalPreserveStackTrace",
+                                         BindingFlags.NonPublic | BindingFlags.Instance);
+
+        static public Exception preserve_stack_trace(this Exception exception)
+        {
+            method.Invoke(exception, new object[0]);
+            return exception;
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,7 @@
+namespace Gorilla.Commons.Infrastructure.Proxies
+{
+    public interface Interceptor
+    {
+        void intercept(Invocation invocation);
+    }
+}
\ No newline at end of file

@@ -0,0 +1,12 @@
+using System.Reflection;
+
+namespace Gorilla.Commons.Infrastructure.Proxies
+{
+    public interface Invocation
+    {
+        void proceed();
+        object[] arguments { get; }
+        MethodInfo method { get; }
+        object return_value { get; set; }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,47 @@
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.Remoting.Messaging;
+using gorilla.commons.utility;
+
+namespace Gorilla.Commons.Infrastructure.Proxies
+{
+    public class MethodCallInvocation<T> : Invocation
+    {
+        readonly IMethodCallMessage call;
+        readonly T target;
+        readonly Stack<Interceptor> interceptors;
+
+        public MethodCallInvocation(IEnumerable<Interceptor> interceptors, IMethodCallMessage call, T target)
+        {
+            this.call = call;
+            this.target = target;
+            this.interceptors = new Stack<Interceptor>(interceptors);
+            arguments = call.Properties["__Args"].downcast_to<object[]>();
+            method = call.MethodBase.downcast_to<MethodInfo>();
+        }
+
+        public object[] arguments { get; set; }
+
+        public MethodInfo method { get; set; }
+
+        public object return_value { get; set; }
+
+        public void proceed()
+        {
+            if (interceptors.Count > 0)
+            {
+                interceptors.Pop().intercept(this);
+                return;
+            }
+
+            try
+            {
+                return_value = call.MethodBase.Invoke(target, arguments);
+            }
+            catch (TargetInvocationException e)
+            {
+                throw e.InnerException.preserve_stack_trace();
+            }
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,10 @@
+namespace Gorilla.Commons.Infrastructure.Proxies
+{
+    static public class ProxyFactory
+    {
+        static public T create<T>(T target, params Interceptor[] interceptors)
+        {
+            return new RemotingProxyFactory<T>(target, interceptors).create_proxy();
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,60 @@
+using developwithpassion.bdd.contexts;
+using Gorilla.Commons.Testing;
+
+namespace Gorilla.Commons.Infrastructure.Proxies
+{
+    public class ProxyFactorySpecs
+    {
+        [Concern(typeof (ProxyFactory))]
+        public class when_proxying_a_class_with_interceptors_applied : concerns
+        {
+            context c = () =>
+            {
+                interceptors = new MyNameIsSlimShadyInterceptor();
+                marshal_mathers = new Person("marshall mathers");
+            };
+
+            because b =
+                () =>
+                {
+                    some_celebrity = ProxyFactory.create<IPerson>(marshal_mathers, interceptors);
+                };
+
+            it should_all_each_interceptor_to_intercept_the_invocation =
+                () => some_celebrity.what_is_your_name().should_be_equal_to("slim shady");
+
+            static Person marshal_mathers;
+            static IPerson some_celebrity;
+            static Interceptor interceptors;
+        }
+
+        public interface IPerson
+        {
+            string what_is_your_name();
+        }
+
+        public class Person : IPerson
+        {
+            readonly string my_name;
+
+            public Person(string my_name)
+            {
+                this.my_name = my_name;
+            }
+
+            public string what_is_your_name()
+            {
+                return my_name;
+            }
+        }
+
+        public class MyNameIsSlimShadyInterceptor : Interceptor
+        {
+            public void intercept(Invocation invocation)
+            {
+                invocation.proceed();
+                invocation.return_value = "slim shady";
+            }
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.Runtime.Remoting.Messaging;
+using System.Runtime.Remoting.Proxies;
+using gorilla.commons.utility;
+
+namespace Gorilla.Commons.Infrastructure.Proxies
+{
+    public class RemotingProxyFactory<T> : RealProxy
+    {
+        readonly T target;
+        readonly IEnumerable<Interceptor> interceptors;
+
+        public RemotingProxyFactory(T target, IEnumerable<Interceptor> interceptors) : base(typeof (T))
+        {
+            this.target = target;
+            this.interceptors = interceptors;
+        }
+
+        public override IMessage Invoke(IMessage message)
+        {
+            if (message.is_an_implementation_of<IMethodCallMessage>())
+            {
+                var call = message.downcast_to<IMethodCallMessage>();
+                var invocation = new MethodCallInvocation<T>(interceptors, call, target);
+                invocation.proceed();
+                return return_value(invocation.return_value, invocation.arguments, call);
+            }
+            return null;
+        }
+
+        IMessage return_value(object return_value, object[] out_parameters, IMethodCallMessage call)
+        {
+            return new ReturnMessage(return_value,
+                                     out_parameters,
+                                     out_parameters == null ? 0 : out_parameters.Length,
+                                     call.LogicalCallContext, call);
+        }
+
+        public T create_proxy()
+        {
+            return GetTransparentProxy().downcast_to<T>();
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+
+namespace Gorilla.Commons.Infrastructure.Reflection
+{
+    public class ApplicationAssembly : Assembly
+    {
+        readonly System.Reflection.Assembly assembly;
+
+        public ApplicationAssembly(System.Reflection.Assembly assembly)
+        {
+            this.assembly = assembly;
+        }
+
+        public IEnumerable<Type> all_types()
+        {
+            return assembly.GetTypes();
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+
+namespace Gorilla.Commons.Infrastructure.Reflection
+{
+    public interface Assembly
+    {
+        IEnumerable<Type> all_types();
+    }
+}
\ No newline at end of file

@@ -0,0 +1,12 @@
+using System;
+
+namespace Gorilla.Commons.Infrastructure.Reflection
+{
+    public static class EnvironmentExtensions
+    {
+        public static string startup_directory<T>(this T item)
+        {
+            return AppDomain.CurrentDomain.BaseDirectory;
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,32 @@
+using System.Collections;
+using System.Collections.Generic;
+using Gorilla.Commons.Infrastructure.Container;
+using gorilla.commons.utility;
+
+namespace Gorilla.Commons.Infrastructure.Registries
+{
+    public class DefaultRegistry<T> : Registry<T>
+    {
+        readonly DependencyRegistry registry;
+
+        public DefaultRegistry(DependencyRegistry registry)
+        {
+            this.registry = registry;
+        }
+
+        public IEnumerable<T> all()
+        {
+            return registry.get_all<T>();
+        }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            return all().GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+using developwithpassion.bdd.contexts;
+using Gorilla.Commons.Infrastructure.Container;
+using Gorilla.Commons.Testing;
+using gorilla.commons.utility;
+
+namespace Gorilla.Commons.Infrastructure.Registries
+{
+    [Concern(typeof (DefaultRegistry<int>))]
+    public class when_retrieving_all_the_items_from_the_default_repository :
+        concerns_for<Registry<int>, DefaultRegistry<int>>
+    {
+        it should_leverage_the_resolver_to_retrieve_all_the_implementations =
+            () => registry.was_told_to(r => r.get_all<int>());
+
+        it should_return_the_items_resolved_by_the_registry = () => result.should_contain(24);
+
+        context c = () =>
+                        {
+                            var items_to_return = new List<int> {24};
+                            registry = an<DependencyRegistry>();
+                            registry.is_told_to(r => r.get_all<int>()).it_will_return(items_to_return);
+                        };
+
+        public override Registry<int> create_sut()
+        {
+            return new DefaultRegistry<int>(registry);
+        }
+
+        because b = () => { result = sut.all(); };
+
+        static DependencyRegistry registry;
+        static IEnumerable<int> result;
+    }
+}
\ No newline at end of file

@@ -0,0 +1,117 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{AA5EEED9-4531-45F7-AFCD-AD9717D2E405}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>gorilla.commons.infrastructure</RootNamespace>
+    <AssemblyName>gorilla.commons.infrastructure</AssemblyName>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="bdddoc, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\build\lib\test\bdd.doc\bdddoc.dll</HintPath>
+    </Reference>
+    <Reference Include="developwithpassion.bdd, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\build\lib\test\developwithpassion\developwithpassion.bdd.dll</HintPath>
+    </Reference>
+    <Reference Include="MbUnit.Framework, Version=2.4.2.175, Culture=neutral, PublicKeyToken=5e72ecd30bc408d5">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\build\lib\test\mbunit\MbUnit.Framework.dll</HintPath>
+    </Reference>
+    <Reference Include="Rhino.Mocks, Version=3.5.0.1337, Culture=neutral, PublicKeyToken=0b3305902db7183f, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\build\lib\test\rhino.mocks\Rhino.Mocks.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Xml.Linq">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data.DataSetExtensions">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="cloning\BinarySerializer.cs" />
+    <Compile Include="cloning\BinarySerializerSpecs.cs" />
+    <Compile Include="cloning\Serializer.cs" />
+    <Compile Include="cloning\Prototype.cs" />
+    <Compile Include="cloning\FileStreamSerializer.cs" />
+    <Compile Include="container\DependencyResolutionException.cs" />
+    <Compile Include="container\DependencyRegistry.cs" />
+    <Compile Include="container\Resolve.cs" />
+    <Compile Include="container\ResolveSpecs.cs" />
+    <Compile Include="debugging\Launch.cs" />
+    <Compile Include="filesystem\ApplicationFile.cs" />
+    <Compile Include="filesystem\File.cs" />
+    <Compile Include="logging\TextLogger.cs" />
+    <Compile Include="logging\LogFactory.cs" />
+    <Compile Include="logging\Loggable.cs" />
+    <Compile Include="logging\Logger.cs" />
+    <Compile Include="logging\Log.cs" />
+    <Compile Include="logging\LoggingExtensions.cs" />
+    <Compile Include="logging\LogSpecs.cs" />
+    <Compile Include="proxies\ExceptionExtensions.cs" />
+    <Compile Include="proxies\Interceptor.cs" />
+    <Compile Include="proxies\Invocation.cs" />
+    <Compile Include="proxies\MethodCallInvocation.cs" />
+    <Compile Include="proxies\ProxyFactory.cs" />
+    <Compile Include="proxies\ProxyFactorySpecs.cs" />
+    <Compile Include="proxies\RemotingProxyFactory.cs" />
+    <Compile Include="reflection\ApplicationAssembly.cs" />
+    <Compile Include="reflection\EnvironmentExtensions.cs" />
+    <Compile Include="reflection\Assembly.cs" />
+    <Compile Include="registries\DefaultRegistry.cs" />
+    <Compile Include="registries\DefaultRegistrySpecs.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\testing\test.helpers.csproj">
+      <Project>{44E65096-9657-4716-90F8-4535BABE8039}</Project>
+      <Name>test.helpers</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\utility\utility.csproj">
+      <Project>{DD8FD29E-7424-415C-9BA3-7D9F6ECBA161}</Project>
+      <Name>utility</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="Properties\" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
\ No newline at end of file

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using Autofac;
+using Gorilla.Commons.Infrastructure.Container;
+
+namespace gorilla.commons.infrastructure.thirdparty.autofac
+{
+    internal class AutofacDependencyRegistry : DependencyRegistry
+    {
+        readonly Func<IContainer> container;
+
+        public AutofacDependencyRegistry(Func<IContainer> container)
+        {
+            this.container = container;
+        }
+
+        public Interface get_a<Interface>()
+        {
+            return container().Resolve<Interface>();
+        }
+
+        public IEnumerable<Interface> get_all<Interface>()
+        {
+            return container().Resolve<IEnumerable<Interface>>();
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,71 @@
+using System;
+using Autofac;
+using Autofac.Builder;
+using Autofac.Modules;
+using Gorilla.Commons.Infrastructure.Container;
+using gorilla.commons.infrastructure.thirdparty.autofac;
+using gorilla.commons.infrastructure.thirdparty.Castle.DynamicProxy;
+using gorilla.commons.utility;
+
+namespace gorilla.commons.infrastructure.thirdparty.Autofac
+{
+    public class AutofacDependencyRegistryBuilder : DependencyRegistration
+    {
+        readonly ContainerBuilder builder;
+        readonly Func<IContainer> container;
+
+        public AutofacDependencyRegistryBuilder() : this(new ContainerBuilder())
+        {
+        }
+
+        public AutofacDependencyRegistryBuilder(ContainerBuilder builder)
+        {
+            this.builder = builder;
+            builder.RegisterModule(new ImplicitCollectionSupportModule());
+            builder.SetDefaultScope(InstanceScope.Factory);
+            container = () => builder.Build();
+            container = container.memorize();
+        }
+
+        public void singleton<Contract, Implementation>() where Implementation : Contract
+        {
+            builder.Register<Implementation>().As<Contract>().SingletonScoped();
+        }
+
+        public void singleton<Contract>(Func<Contract> instance_of_the_contract)
+        {
+            builder.Register(x => instance_of_the_contract()).As<Contract>().SingletonScoped();
+        }
+
+        public void transient<Contract, Implementation>() where Implementation : Contract
+        {
+            transient(typeof (Contract), typeof (Implementation));
+        }
+
+        public void transient(Type contract, Type implementation)
+        {
+            if (contract.is_a_generic_type())
+                builder.RegisterGeneric(implementation).As(contract).FactoryScoped();
+            else
+                builder.Register(implementation).As(contract).FactoryScoped();
+        }
+
+        public void proxy<T>(Configuration<ProxyBuilder<T>> configuration, Func<T> target)
+        {
+            var proxy_builder = new CastleDynamicProxyBuilder<T>();
+            configuration.configure(proxy_builder);
+            builder.Register(x => proxy_builder.create_proxy_for(target)).As<T>().FactoryScoped();
+        }
+
+        public void proxy<T, Configuration>(Func<T> target)
+            where Configuration : Configuration<ProxyBuilder<T>>, new()
+        {
+            proxy(new Configuration(), target);
+        }
+
+        public DependencyRegistry build()
+        {
+            return new AutofacDependencyRegistry(container);
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,71 @@
+using System.Collections.Generic;
+using System.Linq;
+using Autofac;
+using Autofac.Builder;
+using Autofac.Modules;
+using developwithpassion.bdd.contexts;
+using Gorilla.Commons.Testing;
+
+namespace gorilla.commons.infrastructure.thirdparty.autofac
+{
+    [Concern(typeof (ContainerBuilder))]
+    public class when_trying_to_register_a_single_item_in_the_autofac_container : concerns
+    {
+        it should_resolve_that_item = () => result.should_be_an_instance_of<A>();
+
+        context c = () =>
+        {
+            builder = new ContainerBuilder();
+            builder.Register<A>().As<ITestItem>().FactoryScoped();
+            container = builder.Build();
+        };
+
+        because b = () => { result = container.Resolve<ITestItem>(); };
+
+        after_each_observation after_each = () => container.Dispose();
+
+        static ContainerBuilder builder;
+        static IContainer container;
+        static ITestItem result;
+    }
+
+    [Concern(typeof (ContainerBuilder))]
+    public class when_trying_to_resolve_all_the_components_that_implement_a_common_interface : concerns
+    {
+        it should_return_each_component = () =>
+        {
+            results.Count().should_be_equal_to(2);
+            results.First().should_be_an_instance_of<A>();
+            results.Skip(1).First().should_be_an_instance_of<B>();
+        };
+
+        context c = () =>
+        {
+            builder = new ContainerBuilder();
+            builder.RegisterModule(new ImplicitCollectionSupportModule());
+            builder.Register<A>().As<ITestItem>().FactoryScoped();
+            builder.Register<B>().As<ITestItem>().FactoryScoped();
+            container = builder.Build();
+        };
+
+        because b = () => { results = container.Resolve<IEnumerable<ITestItem>>(); };
+
+        after_each_observation after_each = () => container.Dispose();
+
+        static ContainerBuilder builder;
+        static IContainer container;
+        static IEnumerable<ITestItem> results;
+    }
+
+    public interface ITestItem
+    {
+    }
+
+    public class A : ITestItem
+    {
+    }
+
+    public class B : ITestItem
+    {
+    }
+}
\ No newline at end of file

@@ -0,0 +1,41 @@
+using System.Collections.Generic;
+using Castle.Core.Interceptor;
+using gorilla.commons.utility;
+
+namespace gorilla.commons.infrastructure.thirdparty.Castle.DynamicProxy.Interceptors
+{
+    public class CastleDynamicMethodCallTracker<TypeToProxy> : MethodCallTracker<TypeToProxy>
+    {
+        readonly IList<string> the_name_of_each_method_to_intercept;
+
+        public CastleDynamicMethodCallTracker() : this(new List<string>())
+        {
+        }
+
+        public CastleDynamicMethodCallTracker(IList<string> the_name_of_each_method_to_intercept)
+        {
+            this.the_name_of_each_method_to_intercept = the_name_of_each_method_to_intercept;
+        }
+
+        public TypeToProxy target { get; set; }
+
+        public void Intercept(IInvocation invocation)
+        {
+            set_return_value_for(invocation);
+            if (the_name_of_each_method_to_intercept.Contains(invocation.Method.Name)) return;
+            the_name_of_each_method_to_intercept.Add(invocation.Method.Name);
+        }
+
+        public IEnumerable<string> methods_to_intercept()
+        {
+            return the_name_of_each_method_to_intercept;
+        }
+
+        static void set_return_value_for(IInvocation invocation)
+        {
+            var return_type = invocation.Method.ReturnType;
+            if (return_type == typeof (void)) return;
+            invocation.ReturnValue = return_type.default_value();
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using Castle.Core.Interceptor;
+
+namespace gorilla.commons.infrastructure.thirdparty.Castle.DynamicProxy.Interceptors
+{
+    public interface MethodCallTracker<TypeToProxy> : IInterceptor
+    {
+        TypeToProxy target { get; }
+        IEnumerable<string> methods_to_intercept();
+    }
+}
\ No newline at end of file

@@ -0,0 +1,48 @@
+using System.Collections.Generic;
+using System.Linq;
+using Castle.Core.Interceptor;
+using developwithpassion.bdd.contexts;
+using Gorilla.Commons.Testing;
+
+namespace gorilla.commons.infrastructure.thirdparty.Castle.DynamicProxy.Interceptors
+{
+    [Concern(typeof (CastleDynamicMethodCallTracker<>))]
+    public class behaves_like_method_call_tracker :
+        concerns_for<MethodCallTracker<IAnInterface>, CastleDynamicMethodCallTracker<IAnInterface>>
+    {
+        public override MethodCallTracker<IAnInterface> create_sut()
+        {
+            return new CastleDynamicMethodCallTracker<IAnInterface>();
+        }
+    }
+
+    [Concern(typeof (CastleDynamicMethodCallTracker<>))]
+    public class when_tracking_the_calls_to_intercept_on_a_type : behaves_like_method_call_tracker
+    {
+        static IInvocation invocation;
+        static IEnumerable<string> result;
+
+        context c = () =>
+        {
+            invocation = an<IInvocation>();
+            invocation
+                .is_told_to(s => s.Method)
+                .it_will_return(typeof (IAnInterface).GetMethod("ValueReturningMethodWithAnArgument"));
+        };
+
+        because b = () =>
+        {
+            sut.Intercept(invocation);
+            result = sut.methods_to_intercept();
+        };
+
+        it should_return_all_the_methods_that_are_specified_for_interception =
+            () => result.should_contain(typeof (IAnInterface).GetMethod("ValueReturningMethodWithAnArgument").Name);
+
+        it should_only_contain_the_methods_specified_for_interception = () => result.Count().should_be_equal_to(1);
+
+        it should_specify_the_default_return_value_for_the_method_to_intercept =
+            //() => invocation.was_told_to(i => i.ReturnValue = 0);
+            () => invocation.ReturnValue.should_be_equal_to(0);
+    }
+}
\ No newline at end of file

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+using Castle.Core.Interceptor;
+
+namespace gorilla.commons.infrastructure.thirdparty.Castle.DynamicProxy.Interceptors
+{
+    public class SelectiveInterceptor : IInterceptor
+    {
+        private readonly IList<string> methods_to_intercept;
+        private readonly IInterceptor underlying_interceptor;
+
+        public SelectiveInterceptor(IEnumerable<string> methods_to_intercept, IInterceptor underlying_interceptor)
+        {
+            this.methods_to_intercept = new List<string>(methods_to_intercept);
+            this.underlying_interceptor = underlying_interceptor;
+        }
+
+        public void Intercept(IInvocation invocation)
+        {
+            if (methods_to_intercept.Contains(invocation.Method.Name))
+            {
+                underlying_interceptor.Intercept(invocation);
+                return;
+            }
+            invocation.Proceed();
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,25 @@
+using System;
+using System.ComponentModel;
+using Castle.Core.Interceptor;
+using gorilla.commons.utility;
+
+namespace gorilla.commons.infrastructure.thirdparty.castle.dynamicproxy.interceptors
+{
+    public interface SynchronizedInterceptor : IInterceptor
+    {
+    }
+
+    public class SynchronizeInvokeInterceptor<T> : SynchronizedInterceptor where T : ISynchronizeInvoke
+    {
+        public void Intercept(IInvocation invocation)
+        {
+            var target = invocation.InvocationTarget.downcast_to<T>();
+            target.BeginInvoke(do_it(invocation.Proceed), new object[] {});
+        }
+
+        Delegate do_it(Action action)
+        {
+            return action;
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using gorilla.commons.infrastructure.thirdparty.Castle.DynamicProxy.Interceptors;
+
+namespace gorilla.commons.infrastructure.thirdparty.Castle.DynamicProxy
+{
+    public class CastleDynamicInterceptorConstraint<TypeToPutConstraintOn> : InterceptorConstraint<TypeToPutConstraintOn>
+    {
+        readonly MethodCallTracker<TypeToPutConstraintOn> call_tracker;
+        bool intercept_all_calls;
+
+        public CastleDynamicInterceptorConstraint(MethodCallTracker<TypeToPutConstraintOn> call_tracker)
+        {
+            this.call_tracker = call_tracker;
+        }
+
+        public TypeToPutConstraintOn intercept_on
+        {
+            get { return call_tracker.target; }
+        }
+
+        public void intercept_all()
+        {
+            intercept_all_calls = true;
+        }
+
+        public IEnumerable<string> methods_to_intercept()
+        {
+            return intercept_all_calls ? gell_all_methods() : call_tracker.methods_to_intercept();
+        }
+
+        IEnumerable<string> gell_all_methods()
+        {
+            return all_methods().Select(x => x.Name);
+        }
+
+        IEnumerable<MethodInfo> all_methods()
+        {
+            return typeof (TypeToPutConstraintOn).GetMethods(BindingFlags.Public | BindingFlags.Instance);
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,21 @@
+namespace gorilla.commons.infrastructure.thirdparty.Castle.DynamicProxy
+{
+    public class CastleDynamicInterceptorConstraintFactory : InterceptorConstraintFactory
+    {
+        readonly MethodCallTrackerFactory factory;
+
+        public CastleDynamicInterceptorConstraintFactory() : this(new CastleDynamicMethodCallTrackerFactory())
+        {
+        }
+
+        public CastleDynamicInterceptorConstraintFactory(MethodCallTrackerFactory factory)
+        {
+            this.factory = factory;
+        }
+
+        public InterceptorConstraint<Type> CreateFor<Type>()
+        {
+            return new CastleDynamicInterceptorConstraint<Type>(factory.create_for<Type>());
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,27 @@
+using Castle.DynamicProxy;
+using gorilla.commons.infrastructure.thirdparty.Castle.DynamicProxy.Interceptors;
+
+namespace gorilla.commons.infrastructure.thirdparty.Castle.DynamicProxy
+{
+    public class CastleDynamicMethodCallTrackerFactory : MethodCallTrackerFactory
+    {
+        private readonly ProxyGenerator generator;
+
+        public CastleDynamicMethodCallTrackerFactory() : this(new ProxyGenerator())
+        {
+        }
+
+        public CastleDynamicMethodCallTrackerFactory(ProxyGenerator generator)
+        {
+            this.generator = generator;
+        }
+
+        public MethodCallTracker<TypeToProxy> create_for<TypeToProxy>()
+        {
+            var call_tracker_interceptor = new CastleDynamicMethodCallTracker<TypeToProxy>();
+            var target = generator.CreateInterfaceProxyWithoutTarget<TypeToProxy>(call_tracker_interceptor);
+            call_tracker_interceptor.target = target;
+            return call_tracker_interceptor;
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,66 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Castle.Core.Interceptor;
+using gorilla.commons.infrastructure.thirdparty.Castle.DynamicProxy.Interceptors;
+
+namespace gorilla.commons.infrastructure.thirdparty.Castle.DynamicProxy
+{
+    public class CastleDynamicProxyBuilder<TypeToProxy> : ProxyBuilder<TypeToProxy>
+    {
+        readonly IDictionary<IInterceptor, InterceptorConstraint<TypeToProxy>> constraints;
+        readonly ProxyFactory proxy_factory;
+        readonly InterceptorConstraintFactory constraint_factory;
+
+        public CastleDynamicProxyBuilder() : this(new CastleDynamicProxyFactory(), new CastleDynamicInterceptorConstraintFactory())
+        {
+        }
+
+        public CastleDynamicProxyBuilder(ProxyFactory proxy_factory, InterceptorConstraintFactory constraint_factory)
+        {
+            this.proxy_factory = proxy_factory;
+            this.constraint_factory = constraint_factory;
+            constraints = new Dictionary<IInterceptor, InterceptorConstraint<TypeToProxy>>();
+        }
+
+        public ConstraintSelector<TypeToProxy> add_interceptor<Interceptor>(Interceptor interceptor)
+            where Interceptor : IInterceptor
+        {
+            var constraint = constraint_factory.CreateFor<TypeToProxy>();
+            constraints.Add(interceptor, constraint);
+            return constraint;
+        }
+
+        public ConstraintSelector<TypeToProxy> add_interceptor<Interceptor>() where Interceptor : IInterceptor, new()
+        {
+            return add_interceptor(new Interceptor());
+        }
+
+        public TypeToProxy create_proxy_for(TypeToProxy target)
+        {
+            return create_proxy_for(() => target);
+        }
+
+        public TypeToProxy create_proxy_for(Func<TypeToProxy> target)
+        {
+            return proxy_factory.create_proxy_for(target, all_interceptors_with_their_constraints().ToArray());
+        }
+
+        IEnumerable<IInterceptor> all_interceptors_with_their_constraints()
+        {
+            foreach (var pair in constraints)
+            {
+                var constraint = pair.Value;
+                var interceptor = pair.Key;
+                if (constraint.methods_to_intercept().Count() > 0)
+                {
+                    yield return new SelectiveInterceptor(constraint.methods_to_intercept(), interceptor);
+                }
+                else
+                {
+                    yield return interceptor;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Castle.Core.Interceptor;
+using Castle.DynamicProxy;
+using gorilla.commons.infrastructure.thirdparty.castle.dynamicproxy;
+
+namespace gorilla.commons.infrastructure.thirdparty.Castle.DynamicProxy
+{
+    public class CastleDynamicProxyFactory : ProxyFactory
+    {
+        readonly ProxyGenerator generator;
+
+        public CastleDynamicProxyFactory() : this(new ProxyGenerator())
+        {
+        }
+
+        public CastleDynamicProxyFactory(ProxyGenerator generator)
+        {
+            this.generator = generator;
+        }
+
+        public TypeToProxy create_proxy_for<TypeToProxy>(Func<TypeToProxy> implementation, params IInterceptor[] interceptors)
+        {
+            return create_proxy_for(lazy_load(implementation), interceptors);
+        }
+
+        T lazy_load<T>(Func<T> implementation)
+        {
+            if (typeof (T).IsInterface)
+            {
+                return generator.CreateInterfaceProxyWithoutTarget<T>(new LazyLoadedInterceptor<T>(implementation));
+            }
+            return generator.CreateClassProxy<T>(new LazyLoadedInterceptor<T>(implementation));
+        }
+
+        TypeToProxy create_proxy_for<TypeToProxy>(TypeToProxy implementation,
+                                                  IEnumerable<IInterceptor> interceptors)
+        {
+            if (typeof (TypeToProxy).IsInterface)
+            {
+                return generator.CreateInterfaceProxyWithTarget<TypeToProxy>(implementation, interceptors.ToArray());
+            }
+            var list = interceptors.ToList();
+            list.Add(new LazyLoadedInterceptor<TypeToProxy>(() => implementation));
+            return generator.CreateClassProxy<TypeToProxy>(list.ToArray());
+        }
+    }
+}
\ No newline at end of file