diff --git a/Stylet/StyletIoC/Internal/AbstractFactoryBuilder.cs b/Stylet/StyletIoC/Internal/AbstractFactoryBuilder.cs new file mode 100644 index 0000000..54d801c --- /dev/null +++ b/Stylet/StyletIoC/Internal/AbstractFactoryBuilder.cs @@ -0,0 +1,155 @@ +using StyletIoC; +using StyletIoC.Creation; +using StyletIoC.Internal; +using System; +using System.Linq; +using System.Reflection; +using System.Reflection.Emit; +using System.Text; + +namespace StyletIoC.Internal +{ + internal class AbstractFactoryBuilder + { + private readonly ModuleBuilder moduleBuilder; + + public AbstractFactoryBuilder() + { + var assemblyName = new AssemblyName(StyletIoCContainer.FactoryAssemblyName); + var assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run); + + var moduleBuilder = assemblyBuilder.DefineDynamicModule("StyletIoCFactoryModule"); + this.moduleBuilder = moduleBuilder; + } + + public Type GetFactoryForType(Type serviceType) + { + if (serviceType == null) + throw new ArgumentNullException(nameof(serviceType)); + + // Not thread-safe, as it's only called from the builder + if (!serviceType.IsInterface) + throw new StyletIoCCreateFactoryException(String.Format("Unable to create a factory implementing type {0}, as it isn't an interface", serviceType.GetDescription())); + + // If the service is 'ISomethingFactory', call our new class 'GeneratedSomethingFactory' + var typeBuilder = this.moduleBuilder.DefineType(this.CreateImplementationName(serviceType), TypeAttributes.Public); + typeBuilder.AddInterfaceImplementation(serviceType); + + // Define a field which holds a reference to the registration context + var registrationContextField = typeBuilder.DefineField("registrationContext", typeof(IRegistrationContext), FieldAttributes.Private); + + // Add a constructor which takes one argument - the container - and sets the field + // public Name(IRegistrationContext registrationContext) + // { + // this.registrationContext = registrationContext; + // } + var ctorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new[] { typeof(IRegistrationContext) }); + var ilGenerator = ctorBuilder.GetILGenerator(); + // Load 'this' and the registration context onto the stack + ilGenerator.Emit(OpCodes.Ldarg_0); + ilGenerator.Emit(OpCodes.Ldarg_1); + // Store the registration context in this.registrationContext + ilGenerator.Emit(OpCodes.Stfld, registrationContextField); + ilGenerator.Emit(OpCodes.Ret); + + // These are needed by all methods, so get them now + // IRegistrationContext.GetTypeOrAll(Type, string) + // IRegistrationContext extends ICreator, and it's ICreator that actually implements this + var containerGetMethod = typeof(IContainer).GetMethod("GetTypeOrAll", new[] { typeof(Type), typeof(string) }); + // Type.GetTypeFromHandler(RuntimeTypeHandle) + var typeFromHandleMethod = typeof(Type).GetMethod("GetTypeFromHandle"); + + // Go through each method, emmitting an implementation for each + foreach (var methodInfo in serviceType.GetMethods()) + { + var parameters = methodInfo.GetParameters(); + if (!(parameters.Length == 0 || (parameters.Length == 1 && parameters[0].ParameterType == typeof(string)))) + throw new StyletIoCCreateFactoryException("Can only implement methods with zero arguments, or a single string argument"); + + if (methodInfo.ReturnType == typeof(void)) + throw new StyletIoCCreateFactoryException("Can only implement methods which return something"); + + var attribute = methodInfo.GetCustomAttribute(true); + + var methodBuilder = typeBuilder.DefineMethod(methodInfo.Name, MethodAttributes.Public | MethodAttributes.Virtual, methodInfo.ReturnType, parameters.Select(x => x.ParameterType).ToArray()); + var methodIlGenerator = methodBuilder.GetILGenerator(); + // Load 'this' onto stack + // Stack: [this] + methodIlGenerator.Emit(OpCodes.Ldarg_0); + // Load value of 'registrationContext' field of 'this' onto stack + // Stack: [this.registrationContext] + methodIlGenerator.Emit(OpCodes.Ldfld, registrationContextField); + // New local variable which represents type to load + LocalBuilder lb = methodIlGenerator.DeclareLocal(methodInfo.ReturnType); + // Load this onto the stack. This is a RuntimeTypeHandle + // Stack: [this.registrationContext, runtimeTypeHandleOfReturnType] + methodIlGenerator.Emit(OpCodes.Ldtoken, lb.LocalType); + // Invoke Type.GetTypeFromHandle with this + // This is equivalent to calling typeof(T) + // Stack: [this.registrationContext, typeof(returnType)] + methodIlGenerator.Emit(OpCodes.Call, typeFromHandleMethod); + // Load the given key (if it's a parameter), or the key from the attribute if given, or null, onto the stack + // Stack: [this.registrationContext, typeof(returnType), key] + if (parameters.Length == 0) + { + if (attribute == null) + methodIlGenerator.Emit(OpCodes.Ldnull); + else + methodIlGenerator.Emit(OpCodes.Ldstr, attribute.Key); // Load null as the key + } + else + { + methodIlGenerator.Emit(OpCodes.Ldarg_1); // Load the given string as the key + } + // Call container.Get(type, key) + // Stack: [returnedInstance] + methodIlGenerator.Emit(OpCodes.Callvirt, containerGetMethod); + methodIlGenerator.Emit(OpCodes.Ret); + + typeBuilder.DefineMethodOverride(methodBuilder, methodInfo); + } + + Type constructedType; + try + { + constructedType = typeBuilder.CreateType(); + } + catch (TypeLoadException e) + { + throw new StyletIoCCreateFactoryException(String.Format("Unable to create factory type for interface {0}. Ensure that the interface is public, or add [assembly: InternalsVisibleTo(StyletIoCContainer.FactoryAssemblyName)] to your AssemblyInfo.cs", serviceType.GetDescription()), e); + } + + return constructedType; + } + + private void AddFriendlierNameForType(StringBuilder sb, Type type) + { + var typeInfo = type.GetTypeInfo(); + if (typeInfo.IsGenericType) + { + sb.Append(type.GetGenericTypeDefinition().FullName.Replace('.', '+')); + sb.Append("<>["); // Just so that they can't fool us with carefully-crafted interface names... + foreach (var arg in typeInfo.GetGenericArguments()) + { + this.AddFriendlierNameForType(sb, arg); + } + sb.Append("]"); + } + else + { + sb.Append(type.FullName.Replace('.', '+')); + } + sb.Append("<>").Append(typeInfo.Assembly.GetName().Name.Replace('.', '+')); + } + + private string CreateImplementationName(Type interfaceType) + { + var sb = new StringBuilder(); + // Make this unspeakable, just in case... + sb.Append("Stylet.AutoGenerated.<>"); + this.AddFriendlierNameForType(sb, interfaceType); + return sb.ToString(); + } + + } +} diff --git a/Stylet/StyletIoC/Internal/Container.cs b/Stylet/StyletIoC/Internal/Container.cs index a800b33..53b5520 100644 --- a/Stylet/StyletIoC/Internal/Container.cs +++ b/Stylet/StyletIoC/Internal/Container.cs @@ -9,7 +9,7 @@ using System.Diagnostics; using System.Diagnostics.CodeAnalysis; using System.Linq; using System.Reflection; -using System.Reflection.Emit; + namespace StyletIoC.Internal { @@ -45,9 +45,9 @@ namespace StyletIoC.Internal private readonly ConcurrentDictionary builderUppers = new ConcurrentDictionary(); /// - /// Cached ModuleBuilder used for building factory implementations + /// Builder used to build abstract factories /// - private ModuleBuilder factoryBuilder; + private AbstractFactoryBuilder abstractFactoryBuilder; /// /// Fired when this container is asked to dispose @@ -431,107 +431,10 @@ namespace StyletIoC.Internal internal Type GetFactoryForType(Type serviceType) { - // Not thread-safe, as it's only called from the builder - if (!serviceType.IsInterface) - throw new StyletIoCCreateFactoryException(String.Format("Unable to create a factory implementing type {0}, as it isn't an interface", serviceType.GetDescription())); + if (this.abstractFactoryBuilder == null) + this.abstractFactoryBuilder = new AbstractFactoryBuilder(); - if (this.factoryBuilder == null) - { - var assemblyName = new AssemblyName(StyletIoCContainer.FactoryAssemblyName); - var assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run); - var moduleBuilder = assemblyBuilder.DefineDynamicModule("StyletIoCFactoryModule"); - this.factoryBuilder = moduleBuilder; - } - - // If the service is 'ISomethingFactory', call our new class 'GeneratedSomethingFactory' - var typeBuilder = this.factoryBuilder.DefineType("Generated" + serviceType.Name.Substring(1), TypeAttributes.Public); - typeBuilder.AddInterfaceImplementation(serviceType); - - // Define a field which holds a reference to the registration context - var registrationContextField = typeBuilder.DefineField("registrationContext", typeof(IRegistrationContext), FieldAttributes.Private); - - // Add a constructor which takes one argument - the container - and sets the field - // public Name(IRegistrationContext registrationContext) - // { - // this.registrationContext = registrationContext; - // } - var ctorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new[] { typeof(IRegistrationContext) }); - var ilGenerator = ctorBuilder.GetILGenerator(); - // Load 'this' and the registration context onto the stack - ilGenerator.Emit(OpCodes.Ldarg_0); - ilGenerator.Emit(OpCodes.Ldarg_1); - // Store the registration context in this.registrationContext - ilGenerator.Emit(OpCodes.Stfld, registrationContextField); - ilGenerator.Emit(OpCodes.Ret); - - // These are needed by all methods, so get them now - // IRegistrationContext.GetTypeOrAll(Type, string) - // IRegistrationContext extends ICreator, and it's ICreator that actually implements this - var containerGetMethod = typeof(IContainer).GetMethod("GetTypeOrAll", new[] { typeof(Type), typeof(string) }); - // Type.GetTypeFromHandler(RuntimeTypeHandle) - var typeFromHandleMethod = typeof(Type).GetMethod("GetTypeFromHandle"); - - // Go through each method, emmitting an implementation for each - foreach (var methodInfo in serviceType.GetMethods()) - { - var parameters = methodInfo.GetParameters(); - if (!(parameters.Length == 0 || (parameters.Length == 1 && parameters[0].ParameterType == typeof(string)))) - throw new StyletIoCCreateFactoryException("Can only implement methods with zero arguments, or a single string argument"); - - if (methodInfo.ReturnType == typeof(void)) - throw new StyletIoCCreateFactoryException("Can only implement methods which return something"); - - var attribute = methodInfo.GetCustomAttribute(true); - - var methodBuilder = typeBuilder.DefineMethod(methodInfo.Name, MethodAttributes.Public | MethodAttributes.Virtual, methodInfo.ReturnType, parameters.Select(x => x.ParameterType).ToArray()); - var methodIlGenerator = methodBuilder.GetILGenerator(); - // Load 'this' onto stack - // Stack: [this] - methodIlGenerator.Emit(OpCodes.Ldarg_0); - // Load value of 'registrationContext' field of 'this' onto stack - // Stack: [this.registrationContext] - methodIlGenerator.Emit(OpCodes.Ldfld, registrationContextField); - // New local variable which represents type to load - LocalBuilder lb = methodIlGenerator.DeclareLocal(methodInfo.ReturnType); - // Load this onto the stack. This is a RuntimeTypeHandle - // Stack: [this.registrationContext, runtimeTypeHandleOfReturnType] - methodIlGenerator.Emit(OpCodes.Ldtoken, lb.LocalType); - // Invoke Type.GetTypeFromHandle with this - // This is equivalent to calling typeof(T) - // Stack: [this.registrationContext, typeof(returnType)] - methodIlGenerator.Emit(OpCodes.Call, typeFromHandleMethod); - // Load the given key (if it's a parameter), or the key from the attribute if given, or null, onto the stack - // Stack: [this.registrationContext, typeof(returnType), key] - if (parameters.Length == 0) - { - if (attribute == null) - methodIlGenerator.Emit(OpCodes.Ldnull); - else - methodIlGenerator.Emit(OpCodes.Ldstr, attribute.Key); // Load null as the key - } - else - { - methodIlGenerator.Emit(OpCodes.Ldarg_1); // Load the given string as the key - } - // Call container.Get(type, key) - // Stack: [returnedInstance] - methodIlGenerator.Emit(OpCodes.Callvirt, containerGetMethod); - methodIlGenerator.Emit(OpCodes.Ret); - - typeBuilder.DefineMethodOverride(methodBuilder, methodInfo); - } - - Type constructedType; - try - { - constructedType = typeBuilder.CreateType(); - } - catch (TypeLoadException e) - { - throw new StyletIoCCreateFactoryException(String.Format("Unable to create factory type for interface {0}. Ensure that the interface is public, or add [assembly: InternalsVisibleTo(StyletIoCContainer.FactoryAssemblyName)] to your AssemblyInfo.cs", serviceType.GetDescription()), e); - } - - return constructedType; + return this.abstractFactoryBuilder.GetFactoryForType(serviceType); } public BuilderUpper GetBuilderUpper(Type type) diff --git a/Stylet/StyletIoC/StyletIoCBuilder.cs b/Stylet/StyletIoC/StyletIoCBuilder.cs index 299fa58..1e12176 100644 --- a/Stylet/StyletIoC/StyletIoCBuilder.cs +++ b/Stylet/StyletIoC/StyletIoCBuilder.cs @@ -165,15 +165,18 @@ namespace StyletIoC var container = new Container(this.autobindAssemblies); // Just in case they want it - this.Bind().ToInstance(container).DisposeWithContainer(false).AsWeakBinding(); + var bindings = this.bindings.ToList(); + var containerBuilderBindTo = new BuilderBindTo(typeof(IContainer), this.GetAssemblies); + containerBuilderBindTo.ToInstance(container).DisposeWithContainer(false).AsWeakBinding(); + bindings.Add(containerBuilderBindTo); // For each binding which is weak, if another binding exists with any of the same type+key which is strong, we remove this binding - var groups = (from binding in this.bindings + var groups = (from binding in bindings from serviceType in binding.ServiceTypes select new { ServiceType = serviceType, Binding = binding }) .ToLookup(x => x.ServiceType); - var filtered = from binding in this.bindings + var filtered = from binding in bindings where !(binding.IsWeak && binding.ServiceTypes.Any(serviceType => groups.Contains(serviceType) && groups[serviceType].Any(groupItem => !groupItem.Binding.IsWeak))) select binding; diff --git a/StyletUnitTests/StyletIoC/StyletIoCFactoryTests.cs b/StyletUnitTests/StyletIoC/StyletIoCFactoryTests.cs index 339dc87..aa584ca 100644 --- a/StyletUnitTests/StyletIoC/StyletIoCFactoryTests.cs +++ b/StyletUnitTests/StyletIoC/StyletIoCFactoryTests.cs @@ -3,6 +3,14 @@ using StyletIoC; using System.Collections.Generic; using System.Linq; +namespace StyletUnitTests.SubNamespace +{ + public interface I1Factory + { + StyletIoCFactoryTests.I1 GetI1(); + } +} + namespace StyletUnitTests { [TestFixture] @@ -192,5 +200,23 @@ namespace StyletUnitTests var factory = ioc.Get>(); Assert.IsInstanceOf(factory.GetI1()); } + + [Test] + public void SupportsTwoInterfacesWithTheSameNames() + { + var builder = new StyletIoCBuilder(); + builder.Bind().ToAbstractFactory(); + builder.Bind().ToAbstractFactory(); + Assert.DoesNotThrow(() => builder.BuildContainer()); + } + + [Test] + public void SupportsBuildingTheSameBuilderTwice() + { + var builder = new StyletIoCBuilder(); + builder.Bind().ToAbstractFactory(); + builder.BuildContainer(); + Assert.DoesNotThrow(() => builder.BuildContainer()); + } } }