Unity не может разрешить экземпляры динамически создаваемого класса

Question

РЕШЕНИЕ Я не указывал параметры конструктора для нового типа, поэтому .NET предполагал типы базового класса, однако он также не называет их одинаковыми, поэтому, когда Unity пытается использовать параметр [x]. Имя получило значение Null вместо имени параметра.

Извините, что использую слово "U", но это действительно проблема, мне нужно срочно решить эту проблему, чтобы решить массовую проблему.утечка памяти в другом месте (длинная история). Так что, если кто-то может помочь с этим, я буду очень признателен!

Я динамически создаю тип во время выполнения, используя Reflection.Emit.Динамический тип происходит от базового типа, указанного во время выполнения, и реализует IController.Цель состоит в том, чтобы обернуть вызов IController.Execute с помощью try ... finally и избавиться от объекта.

Вот что странно.Я могу создать экземпляр этого нового типа, например так:

var requiredDependency = new Logger();
Type interceptingControllerType = CreateInterceptingControllerType(superClass);
var constructorInfo = interceptingControllerType.GetConstructor(new Type[] { typeof(Logger) });
var result = (IController)constructorInfo.Invoke(new object[] { requiredDependency });

Я также могу использовать единицу для разрешения суперкласса, например так:

var superClassThatWillResolve = container.Resolve(superClass);

Но я не могу использовать единство для разрешениядинамически создаваемый подкласс

var newSubClassThatWontResolve = container.Resolve(interceptingControllerType);

Когда я пробую последний вариант, я получаю следующее исключение

Microsoft.Practices.Unity.ResolutionFailedException was unhandled
  Message=Resolution of the dependency failed, type = "9d206a0c-2c78-43d1-8907-8227ad1242f1", name = "(none)".
Exception occurred while: while resolving.
Exception is: ArgumentNullException - Value cannot be null.
Parameter name: str
-----------------------------------------------
At the time of the exception, the container was:

  Resolving 9d206a0c-2c78-43d1-8907-8227ad1242f1,(none)

  Source=Microsoft.Practices.Unity
  TypeRequested=9d206a0c-2c78-43d1-8907-8227ad1242f1
  StackTrace:
       at Microsoft.Practices.Unity.UnityContainer.DoBuildUp(Type t, Object existing, String name, IEnumerable`1 resolverOverrides)
       at Microsoft.Practices.Unity.UnityContainer.DoBuildUp(Type t, String name, IEnumerable`1 resolverOverrides)
       at Microsoft.Practices.Unity.UnityContainer.Resolve(Type t, String name, ResolverOverride[] resolverOverrides)
       at Microsoft.Practices.Unity.UnityContainerExtensions.Resolve(IUnityContainer container, Type t, ResolverOverride[] overrides)
       at ConsoleApplication18.InterceptingControllerBuilder.CreateControllerInterceptor(IUnityContainer container, Type superClass) in C:\Users\PeterMorris\Documents\Visual Studio 2010\Projects\ConsoleApplication18\InterceptingControllerBuilder.cs:line 24
       at ConsoleApplication18.Program.Main(String[] args) in C:\Users\PeterMorris\Documents\Visual Studio 2010\Projects\ConsoleApplication18\Program.cs:line 15
       at System.AppDomain._nExecuteAssembly(RuntimeAssembly assembly, String[] args)
       at System.AppDomain.ExecuteAssembly(String assemblyFile, Evidence assemblySecurity, String[] args)
       at Microsoft.VisualStudio.HostingProcess.HostProc.RunUsersAssembly()
       at System.Threading.ThreadHelper.ThreadStart_Context(Object state)
       at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean ignoreSyncCtx)
       at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)
       at System.Threading.ThreadHelper.ThreadStart()
  InnerException: System.ArgumentNullException
       Message=Value cannot be null.
Parameter name: str
       Source=mscorlib
       ParamName=str
       StackTrace:
            at System.Reflection.Emit.DynamicILGenerator.Emit(OpCode opcode, String str)
            at Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.PreBuildUp(IBuilderContext context)
            at Microsoft.Practices.ObjectBuilder2.StrategyChain.ExecuteBuildUp(IBuilderContext context)
            at Microsoft.Practices.ObjectBuilder2.DynamicMethodBuildPlanCreatorPolicy.CreatePlan(IBuilderContext context, NamedTypeBuildKey buildKey)
            at Microsoft.Practices.ObjectBuilder2.BuildPlanStrategy.PreBuildUp(IBuilderContext context)
            at Microsoft.Practices.ObjectBuilder2.StrategyChain.ExecuteBuildUp(IBuilderContext context)
            at Microsoft.Practices.Unity.UnityContainer.DoBuildUp(Type t, Object existing, String name, IEnumerable`1 resolverOverrides)
       InnerException: 

Вот код теста ...

using System;
using Microsoft.Practices.Unity;

namespace ConsoleApplication18
{
    class Program
    {
        static void Main(string[] args)
        {
            var container = new UnityContainer();
            var childContainer = container.CreateChildContainer();
            IController interceptingController = InterceptingControllerBuilder.CreateControllerInterceptor(
                childContainer, typeof(CountryController));
            try
            {
                interceptingController.Execute("Hello");
            }
            catch (Exception e)
            {
                Console.WriteLine("Exception: " + e.Message);
            }
            Console.ReadLine();
        }
    }

    public class Logger
    {
        public void Log(string text)
        {
            Console.WriteLine(text);
        }
    }

    public interface IController
    {
        void Execute(string text);
    }

    public class Controller : IController
    {
        readonly Logger Logger;

        public Controller(Logger logger)
        {
            Logger = logger;
        }

        public virtual void Execute(string text)
        {
            Logger.Log("Controller: " + text);
        }
    }

    public class CountryController : Controller
    {
        public CountryController(Logger logger)
            : base(logger)
        {
        }

        public override void Execute(string text)
        {
            base.Execute("CountryController: " + text);
        }
    }
}

Икод реализации

using Microsoft.Practices.Unity;

namespace ConsoleApplication18
{
    public interface IUnityContainerController
    {
        IUnityContainer IUnityContainerController_UnityContainer { get; set; }
    }
}




using System;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using Microsoft.Practices.Unity;

namespace ConsoleApplication18
{
    public static class InterceptingControllerBuilder
    {
        const string UnityContainerBackingFieldName = "IUnityContainerController_BackingField";
        static MethodInfo DisposeMethodInfo = typeof(IDisposable).GetMethod("Dispose");

        public static IController CreateControllerInterceptor(IUnityContainer container, Type superClass)
        {
            var requiredDependency = new Logger();
            Type interceptingControllerType = CreateInterceptingControllerType(superClass);
            var constructorInfo = interceptingControllerType.GetConstructor(new Type[] { typeof(Logger) });
            var result = (IController)constructorInfo.Invoke(new object[] { requiredDependency });
            var resultAsIUnityContainerController = (IUnityContainerController)result;
            resultAsIUnityContainerController.IUnityContainerController_UnityContainer = container;

            var superClassThatWillResolve = container.Resolve(superClass);
            var newSubClassThatWontResolve = container.Resolve(interceptingControllerType);

            return result;
        }

        static Type CreateInterceptingControllerType(Type superClass)
        {
            if (!typeof(IController).IsAssignableFrom(superClass))
                throw new ArgumentException("SuperClass does not implement IController");

            string guid = Guid.NewGuid().ToString();
            var assemblyName = new AssemblyName(guid);
            var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
                assemblyName,
                AssemblyBuilderAccess.Run);
            var moduleBuilder = assemblyBuilder.DefineDynamicModule(guid);
            var typeBuilder = moduleBuilder.DefineType(
                guid,
                TypeAttributes.Class | TypeAttributes.Public,
                superClass);
            CreateConstructor(superClass, typeBuilder);
            FieldBuilder unityContainerBackingFieldBuilder;
            ImplementIUnityContainerController(typeBuilder, out unityContainerBackingFieldBuilder);
            ImplementIController(superClass, typeBuilder, unityContainerBackingFieldBuilder);
            return typeBuilder.CreateType();
        }

        static void CreateConstructor(Type superClass, TypeBuilder typeBuilder)
        {
            var constructorInfo = superClass.GetConstructors()
                .OrderByDescending(x => x.GetParameters().Count())
                .FirstOrDefault();
            if (constructorInfo == null)
                return;
            ParameterInfo[] constructorParameters =
                constructorInfo.GetParameters().ToArray();
            Type[] parameterTypes = constructorParameters.Select(x => x.ParameterType).ToArray();
            var constructorBuilder = typeBuilder.DefineConstructor(
                MethodAttributes.Public,
                CallingConventions.Standard,
                parameterTypes);
            var bodyGenerator = constructorBuilder.GetILGenerator();
            bodyGenerator.Emit(OpCodes.Ldarg_0);
            for (int argumentIndex = 0; argumentIndex < constructorParameters.Count(); argumentIndex++)
                bodyGenerator.Emit(OpCodes.Ldarg, argumentIndex + 1);
            bodyGenerator.Emit(OpCodes.Call, constructorInfo);
            bodyGenerator.Emit(OpCodes.Ret);
        }

        static void ImplementIUnityContainerController(TypeBuilder typeBuilder, out FieldBuilder unityContainerBackingFieldBuilder)
        {
            typeBuilder.AddInterfaceImplementation(typeof(IUnityContainerController));
            unityContainerBackingFieldBuilder = typeBuilder.DefineField(
                UnityContainerBackingFieldName,
                typeof(IUnityContainer),
                FieldAttributes.Private);

            var propertyAccessorAttributes =
                MethodAttributes.Public | MethodAttributes.SpecialName |
                MethodAttributes.HideBySig | MethodAttributes.Virtual;

            var getterBuilder = typeBuilder.DefineMethod(
                "get_IUnityContainerController_UnityContainer",
                propertyAccessorAttributes,
                typeof(IUnityContainer),
                Type.EmptyTypes);
            var getterGenerator = getterBuilder.GetILGenerator();
            getterGenerator.Emit(OpCodes.Ldarg_0);
            getterGenerator.Emit(OpCodes.Ldfld, unityContainerBackingFieldBuilder);
            getterGenerator.Emit(OpCodes.Ret);

            var setterBuilder = typeBuilder.DefineMethod(
                "set_IUnityContainerController_UnityContainer",
                propertyAccessorAttributes,
                null,
                new Type[] { typeof(IUnityContainer) });
            var setterGenerator = setterBuilder.GetILGenerator();
            setterGenerator.Emit(OpCodes.Ldarg_0);
            setterGenerator.Emit(OpCodes.Ldarg_1);
            setterGenerator.Emit(OpCodes.Stfld, unityContainerBackingFieldBuilder);
            setterGenerator.Emit(OpCodes.Ret);
        }

        static void ImplementIController(Type superClass, TypeBuilder typeBuilder, FieldBuilder unityContainerBackingFieldBuilder)
        {
            typeBuilder.AddInterfaceImplementation(typeof(IController));
            MethodInfo interfaceMethod = typeof(IController).GetMethod("Execute");
            InterfaceMapping mapping = superClass.GetInterfaceMap(typeof(IController));
            MethodInfo baseMethod = mapping.TargetMethods.Single();

            var methodBuilder = typeBuilder.DefineMethod(
                typeof(IController).Name + ".Execute",
                MethodAttributes.Public | MethodAttributes.Virtual | 
                MethodAttributes.ReuseSlot | MethodAttributes.HideBySig,
                null,
                new Type[] { typeof(string) });
            var bodyGenerator = methodBuilder.GetILGenerator();
            bodyGenerator.BeginExceptionBlock();
            bodyGenerator.Emit(OpCodes.Ldarg_0);
            bodyGenerator.Emit(OpCodes.Ldarg_1);
            bodyGenerator.Emit(OpCodes.Call, baseMethod);
            bodyGenerator.BeginFinallyBlock();
            bodyGenerator.Emit(OpCodes.Ldarg_0);
            bodyGenerator.Emit(OpCodes.Ldfld, unityContainerBackingFieldBuilder);
            bodyGenerator.Emit(OpCodes.Call, DisposeMethodInfo);
            bodyGenerator.EndExceptionBlock();
            bodyGenerator.Emit(OpCodes.Ret);
            typeBuilder.DefineMethodOverride(methodBuilder, interfaceMethod);
        }
    }
}

Answer 1

Параметры для конструктора для нового типа не были определены, поэтому .NET создал некоторые параметры по умолчанию, которые имели NULL для имен!

//Define the parameters for our new constructor
for (int argumentIndex = 0; argumentIndex < parameterTypes.Length; argumentIndex++)
    constructorBuilder.DefineParameter(
        argumentIndex + 1,
        constructorParameters[argumentIndex].Attributes,
        constructorParameters[argumentIndex].Name);

Answer 2

Я бы сказал, что это потому, что тип создается на лету.Вместо того, чтобы делать это таким образом, почему бы не зарегистрировать фабричную функцию (используя InjectionFactory ) для типа?Это предотвратит попытки Unity создать сам тип и вместо этого использует вашу пользовательскую функцию для создания экземпляра.

Кстати, почему вы создаете такие перехватчики на лету?Вы можете создать перехватчик в Unity и подключать его, а не динамически создавать типы перехватчиков.Это устранит необходимость всего этого кода в первую очередь.