Upgraded to StructureMap 4.0

SharpRepository.Benchmarks.Configuration/Bootstrapper.cs

@@ -1,13 +1,14 @@
 using SharpRepository.Ioc.StructureMap;
 using StructureMap;
+using StructureMap.Graph;
 
 namespace SharpRepository.Benchmarks.Configuration
 {
     public static class Bootstrapper
     {
-        public static void Run()
+        public static Container Run()
         {
-            ObjectFactory.Initialize(x =>
+            var container = new Container(x =>
             {
                 x.Scan(scan =>
                 {
@@ -17,6 +18,8 @@ public static void Run()
 
                 x.ForRepositoriesUseSharpRepository();
             });
+
+            return container;
         }
     }
 }

SharpRepository.Benchmarks.Configuration/Program.cs

@@ -9,6 +9,8 @@
 using SharpRepository.Repository;
 using SharpRepository.Repository.Configuration;
 using StructureMap;
+using StructureMap.Graph;
+using SharpRepository.Ioc.StructureMap;
 
 namespace SharpRepository.Benchmarks.Configuration
 {
@@ -21,51 +23,46 @@ class BenchmarkItem
 
     class Program
     {
-        static Program()
-        {
-            // This loads the StructureMap registry
-            Bootstrapper.Run();
-        }
-
         private const int Max = 250000;
         static void Main(string[] args)
         {
+            var benchmarks = new Benchmarks();
             var tests = new List<BenchmarkItem>()
                             {
                                 new BenchmarkItem()
                                     {
                                         Title = "Direct Creation: [new InMemoryRepository()]",
-                                        Test = DirectCreation,
+                                        Test = Benchmarks.DirectCreation,
                                         Order = 1
                                     },
                                 new BenchmarkItem()
                                     {
                                         Title = "Custom repo hardcoded: [UserRepository : InMemoryRepository<User,int>]",
-                                        Test = CustomRepositoryHardCoded,
+                                        Test = Benchmarks.CustomRepositoryHardCoded,
                                         Order = 2
                                     },
                                 new BenchmarkItem()
                                     {
                                         Title = "From config file: [RepositoryFactory.GetInstance<User, int>()]",
-                                        Test = CreateFromConfigFile,
+                                        Test = Benchmarks.CreateFromConfigFile,
                                         Order = 3
                                     },
                                 new BenchmarkItem()
                                     {
                                         Title = "From config obj: [RepositoryFactory.GetInstance<User, int>(config)]",
-                                        Test = CreateFromConfigObject,
+                                        Test = Benchmarks.CreateFromConfigObject,
                                         Order = 4
                                     },
                                 new BenchmarkItem()
                                     {
                                         Title = "Custom repo config: [UserRepository : ConfigurationBasedRepository<User, int>]",
-                                        Test = CustomRepositoryFromConfig,
+                                        Test = Benchmarks.CustomRepositoryFromConfig,
                                         Order = 5
                                     },
                                 new BenchmarkItem()
                                     {
-                                        Title = "StructureMap w/ config: [ObjectFactory.GetInstance<IRepository<User, int>>()]",
-                                        Test = DirectFromStructureMap,
+                                        Title = "StructureMap w/ config: [container.GetInstance<IRepository<User, int>>()]",
+                                        Test = benchmarks.DirectFromStructureMap,
                                         Order = 6
                                     }
                             };
@@ -99,43 +96,62 @@ static void Main(string[] args)
             Console.WriteLine("\nDone: press enter to quit");
             Console.Read();
         }
+    }
+
+    public class Benchmarks
+    {
+        public Container container { get; set; }
+
+        public Benchmarks()
+        {
+            container = new Container(x =>
+            {
+                x.Scan(scan =>
+                {
+                    scan.TheCallingAssembly();
+                    scan.WithDefaultConventions();
+                });
+
+                x.ForRepositoriesUseSharpRepository();
+            });
+        }
 
         [MethodImpl(MethodImplOptions.NoInlining)]
-        static void DirectCreation()
+        public static void DirectCreation()
         {
             new InMemoryRepository<User, int>();
         }
 
         [MethodImpl(MethodImplOptions.NoInlining)]
-        static void CreateFromConfigFile()
+        public static void CreateFromConfigFile()
         {
             RepositoryFactory.GetInstance<User, int>();
         }
 
         [MethodImpl(MethodImplOptions.NoInlining)]
-        static void CustomRepositoryFromConfig()
+        public static void CustomRepositoryFromConfig()
         {
             new UserFromConfigRepository();
         }
 
         [MethodImpl(MethodImplOptions.NoInlining)]
-        static void CustomRepositoryHardCoded()
+        public static void CustomRepositoryHardCoded()
         {
             new UserRepository();
         }
 
         [MethodImpl(MethodImplOptions.NoInlining)]
-        static void DirectFromStructureMap()
+        public void DirectFromStructureMap()
         {
-            ObjectFactory.GetInstance<IRepository<User, int>>();
+            container.GetInstance<IRepository<User, int>>();
         }
 
         [MethodImpl(MethodImplOptions.NoInlining)]
-        static void CreateFromConfigObject()
+        public static void CreateFromConfigObject()
         {
             var config = new SharpRepositoryConfiguration();
             config.AddRepository(new InMemoryRepositoryConfiguration("default"));
-             RepositoryFactory.GetInstance<User, int>(config);
+            RepositoryFactory.GetInstance<User, int>(config);
         }
     }
 }

SharpRepository.Benchmarks.Configuration/SharpRepository.Benchmarks.Configuration.csproj

@@ -32,8 +32,13 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="StructureMap">
-      <HintPath>..\packages\structuremap.2.6.4.1\lib\net40\StructureMap.dll</HintPath>
+    <Reference Include="StructureMap, Version=4.0.1.318, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\structuremap.4.0.1.318\lib\net40\StructureMap.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="StructureMap.Net4, Version=4.0.1.318, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\structuremap.4.0.1.318\lib\net40\StructureMap.Net4.dll</HintPath>
+      <Private>True</Private>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -44,7 +49,6 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Bootstrapper.cs" />
     <Compile Include="Models\User.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />

SharpRepository.Benchmarks.Configuration/packages.config

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="structuremap" version="2.6.4.1" targetFramework="net45" />
+  <package id="structuremap" version="4.0.1.318" targetFramework="net45" />
 </packages>

SharpRepository.Ioc.StructureMap/Factories/CompoundKey.cs

@@ -0,0 +1,69 @@
+using SharpRepository.Repository;
+using SharpRepository.Repository.Configuration;
+using StructureMap.Building;
+using StructureMap.Pipeline;
+using System;
+
+namespace SharpRepository.Ioc.StructureMap.Factories
+{
+    public class RepositoryCompoundKeyInstanceFactory : Instance
+    {
+        protected string repositoryName;
+        protected ISharpRepositoryConfiguration configuration;
+
+        public RepositoryCompoundKeyInstanceFactory(string repositoryName)
+        {
+            this.repositoryName = repositoryName;
+        }
+
+        public RepositoryCompoundKeyInstanceFactory(ISharpRepositoryConfiguration configuration)
+        {
+            this.configuration = configuration;
+        }
+
+        public override string Description {
+            get {
+                return "Repository factory for class with compound key";
+            }
+        }
+
+        public override Type ReturnedType
+        {
+            get
+            {
+                return typeof(ICompoundKeyRepository<>);
+            }
+        }
+
+        public override IDependencySource ToDependencySource(Type pluginType)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override Instance CloseType(Type[] types)
+        {
+            var instanceType = typeof(RepositoryCompoundKeyInstance<>).MakeGenericType(types);
+
+            if (this.configuration != null) {
+                var ctor = instanceType.GetConstructor(new[] { typeof(ISharpRepositoryConfiguration) });
+                return ctor.Invoke(new object[] { this.configuration }) as Instance;
+            } else {
+                var ctor = instanceType.GetConstructor(new[] { typeof(string) });
+                return ctor.Invoke(new object[] { this.repositoryName }) as Instance;
+            }
+        }
+    }
+
+    public class RepositoryCompoundKeyInstance<T> : LambdaInstance<ICompoundKeyRepository<T>> where T : class, new()
+    {
+        public RepositoryCompoundKeyInstance(string repositoryName)
+            : base(() => RepositoryFactory.GetCompoundKeyInstance<T>( repositoryName))
+        {
+        }
+
+        public RepositoryCompoundKeyInstance(ISharpRepositoryConfiguration configuration)
+         : base(() => RepositoryFactory.GetCompoundKeyInstance<T>(configuration, null))
+        {
+        }
+    }
+}

SharpRepository.Ioc.StructureMap/Factories/DoubleKey.cs

@@ -0,0 +1,69 @@
+using SharpRepository.Repository;
+using SharpRepository.Repository.Configuration;
+using StructureMap.Building;
+using StructureMap.Pipeline;
+using System;
+
+namespace SharpRepository.Ioc.StructureMap.Factories
+{
+    public class RepositoryDoubleKeyInstanceFactory : Instance
+    {
+        protected string repositoryName;
+        protected ISharpRepositoryConfiguration configuration;
+
+        public RepositoryDoubleKeyInstanceFactory(string repositoryName)
+        {
+            this.repositoryName = repositoryName;
+        }
+
+        public RepositoryDoubleKeyInstanceFactory(ISharpRepositoryConfiguration configuration)
+        {
+            this.configuration = configuration;
+        }
+
+        public override string Description {
+            get {
+                return "Repository factory for class with double compound key";
+            }
+        }
+
+        public override Type ReturnedType
+        {
+            get
+            {
+                return typeof(ICompoundKeyRepository<,,>);
+            }
+        }
+
+        public override IDependencySource ToDependencySource(Type pluginType)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override Instance CloseType(Type[] types)
+        {
+            var instanceType = typeof(RepositoryInstance<,,>).MakeGenericType(types);
+
+            if (this.configuration != null) {
+                var ctor = instanceType.GetConstructor(new[] { typeof(ISharpRepositoryConfiguration) });
+                return ctor.Invoke(new object[] { this.configuration }) as Instance;
+            } else {
+                var ctor = instanceType.GetConstructor(new[] { typeof(string) });
+                return ctor.Invoke(new object[] { this.repositoryName }) as Instance;
+            }
+        }
+}
+
+    public class RepositoryInstance<T, TKey, TKey2> : LambdaInstance<ICompoundKeyRepository<T, TKey, TKey2>> where T : class, new()
+    {
+        public RepositoryInstance(string repositoryName)
+            : base(() => RepositoryFactory.GetInstance<T, TKey, TKey2>( repositoryName))
+        {
+        }
+
+        public RepositoryInstance(ISharpRepositoryConfiguration configuration)
+         : base(() => RepositoryFactory.GetInstance<T, TKey, TKey2>(configuration, null))
+        {
+        }
+    }
+}