AP Unittest Framework

using _3S.CoDeSys.Core.ComponentModel;

using _3S.CoDeSys.Core.Components;

using _3S.CoDeSys.Core.Views;

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Reflection;

using System.Xml;

namespace _3S.APUnitTestFramework

{

    [TypeGuid("{638AA04C-726D-4CD1-99EE-CE402D0DD566}")]

    public class ComponentModelImplementation : IComponentModelImplementationForUnitTest

    {

        public IDependencyResolveContext CreateDependencyResolveContext(Profile profile)

        {

            // Not required for unit testing.

            throw new NotImplementedException();

        }

        public IEnumerable<IDependency> GetDependencies(Guid plugInGuid, Version version, bool inproc)

        {

            // Not required for unit testing.

            throw new NotImplementedException();

        }

        public void InjectDependencies(IDependencyInjectable injectable, Type callingType)

        {

            if (injectable == null)

                throw new ArgumentNullException(nameof(injectable));

            if (_dependencyResolver == null)

                throw new InvalidOperationException("No dependency resolver has been set.");

            var type = injectable.GetType();

            foreach (var target in _injectionTargetCache.GetInjectionTargets(type))

            {

                var value = target.GetInjectionValue(callingType);

                value.Prepare(target.Member, _dependencyResolver);

                target.Assign(injectable, value);

            }

            injectable.InjectionComplete();

        }

        public IDependency LoadDependency(XmlElement element)

        {

            // Not required for unit testing.

            throw new NotImplementedException();

        }

        public DependencyResolveResult ResolveDependency(SpecificDependency specificDependency, IDependencyResolveContext context)

        {

            // Not required for unit testing.

            throw new NotImplementedException();

        }

        public DependencyResolveResult ResolveDependency(MultipleDependency multipleDependency, IDependencyResolveContext context)

        {

            // Not required for unit testing.

            throw new NotImplementedException();

        }

        public DependencyResolveResult ResolveDependency(SingleDependency singleDependency, IDependencyResolveContext context)

        {

            // Not required for unit testing.

            throw new NotImplementedException();

        }

        public void Save(SpecificDependency specificDependency, XmlElement parentElement)

        {

            // Not required for unit testing.

            throw new NotImplementedException();

        }

        public void Save(MultipleDependency multipleDependency, XmlElement parentElement)

        {

            // Not required for unit testing.

            throw new NotImplementedException();

        }

        public void SaveDependency(SingleDependency singleDependency, XmlElement parentElement)

        {

            // Not required for unit testing.

            throw new NotImplementedException();

        }

        public void SetupForUnitTest(Testbed testbed, string profileName, Profile profile)

        {

            _dependencyResolver = new DependencyResolver(testbed, profileName, profile);

        }

        private InjectionTargetCache _injectionTargetCache = new InjectionTargetCache();

        private DependencyResolver _dependencyResolver;

    }

    class InjectionTargetCache

    {

        public IEnumerable<AbstractInjectionTarget> GetInjectionTargets(Type type)

        {

            IEnumerable<AbstractInjectionTarget> result;

            _dictionary.TryGetValue(type, out result);

            if (result == null)

            {

                result = GetInjectionTargetsByReflection(type);

                _dictionary[type] = result;

            }

            return result;

        }

        private static IEnumerable<AbstractInjectionTarget> GetInjectionTargetsByReflection(Type type)

        {

            var result = new List<AbstractInjectionTarget>();

            IEnumerable<MemberInfo> properties = type.GetProperties();

            IEnumerable<MemberInfo> fields = type.GetFields();

            foreach (var member in Enumerable.Concat(properties, fields))

            {

                var target = AbstractInjectionTarget.CreateFromMember(member);

                if (target != null)

                    result.Add(target);

            }

            return result;

        }

        private Dictionary<Type, IEnumerable<AbstractInjectionTarget>> _dictionary = new Dictionary<Type, IEnumerable<AbstractInjectionTarget>>();

    }

    abstract class AbstractInjectionTarget

    {

        public MemberInfo Member { get; private set; }

        private IInjectionValue _injectionValue;

        protected AbstractInjectionTarget(MemberInfo member)

        {

            if (member == null)

                throw new ArgumentNullException(nameof(member));

            Member = member;

        }

        public static AbstractInjectionTarget CreateFromMember(MemberInfo member)

        {

            var attr = Attribute.GetCustomAttribute(member, typeof(AbstractInjectAttribute), false);

            if (attr == null)

            {

                return null;

            }

            else if (attr is InjectSingleInstanceAttribute)

            {

                var shared = ((InjectSingleInstanceAttribute)attr).Shared;

                var optional = ((InjectSingleInstanceAttribute)attr).Optional;

                return new SingleInstanceInjectionTarget(shared, optional, member);

            }

            else if (attr is InjectMultipleInstancesAttribute)

            {

                var shared = ((InjectMultipleInstancesAttribute)attr).Shared;

                var optional = ((InjectMultipleInstancesAttribute)attr).Optional;

                return new MultipleInstancesInjectionTarget(shared, optional, member);

            }

            else if (attr is InjectSpecificInstanceAttribute)

            {

                var typeGuid = ((InjectSpecificInstanceAttribute)attr).TypeGuid;

                var shared = ((InjectSpecificInstanceAttribute)attr).Shared;

                var optional = ((InjectSpecificInstanceAttribute)attr).Optional;

                return new SpecificInstanceInjectionTarget(typeGuid, shared, optional, member);

            }

            else if (attr is InjectAnyInstanceAttribute)

            {

                return new AnyInstanceInjectionTarget(member);

            }

            else if (attr is InjectSpecificTypeInformationAttribute)

            {

                var typeGuid = ((InjectSpecificTypeInformationAttribute)attr).TypeGuid;

                var optional = ((InjectSpecificTypeInformationAttribute)attr).Optional;

                return new SpecificTypeInformationInjectionTarget(typeGuid, optional, member);

            }

            else if (attr is InjectAnyTypeInformationAttribute)

            {

                return new AnyTypeInformationInjectionTarget(member);

            }

            else if (attr is InjectActiveProfileAttribute)

            {

                return new ActiveProfileInjectionTarget(member);

            }

            else if (attr is InjectFrameFormAttribute)

            {

                return new FrameFormInjectionTarget(member);

            }

            else

            {

                return null;

            }

        }

        public IInjectionValue GetInjectionValue(Type callingType)

        {

            if (_injectionValue == null)

                _injectionValue = DoGetInjectionValue(callingType);

            return _injectionValue;

        }

        protected abstract IInjectionValue DoGetInjectionValue(Type callingType);

        public void Assign(IDependencyInjectable injectable, IInjectionValue value)

        {

            var field = Member as FieldInfo;

            var property = Member as PropertyInfo;

            if (field != null)

                field.SetValue(injectable, value);

            else if (property != null)

                property.SetValue(injectable, value, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, null, null);

            else

                Debug.Fail("Injection target must be a field or property.");

        }

        protected Type MemberType

        {

            get

            {

                var field = Member as FieldInfo;

                var property = Member as PropertyInfo;

                if (field != null)

                    return field.FieldType;

                else if (property != null)

                    return property.PropertyType;

                else

                    return null;

            }

        }

        protected static bool IsOfGenericType(Type memberType, Type genericType)

        {

            if (!memberType.IsGenericType)

                return false;

            else if (!genericType.IsAssignableFrom(memberType.GetGenericTypeDefinition()))

                return false;

            else

                return true;

        }

    }

    class SingleInstanceInjectionTarget : AbstractInjectionTarget

    {

        public SingleInstanceInjectionTarget(bool shared, bool optional, MemberInfo member)

            : base(member)

        {

            _shared = shared;

            _optional = optional;

        }

        protected override IInjectionValue DoGetInjectionValue(Type callingType)

        {

            Type type;

            if (_shared)

            {

                if (!IsOfGenericType(MemberType, typeof(ISharedSingleInstanceProvider<>)))

                    throw new WrongMemberTypeForInjectionException(Member, typeof(ISharedSingleInstanceProvider<>));

                var contractType = Enumerable.First(MemberType.GetGenericArguments());

                type = _optional ? typeof(OptionalSharedSingleInstanceProvider<>).MakeGenericType(contractType) : typeof(SharedSingleInstanceProvider<>).MakeGenericType(contractType);

            }

            else

            {

                if (!IsOfGenericType(MemberType, typeof(ISingleInstanceProvider<>)))

                    throw new WrongMemberTypeForInjectionException(Member, typeof(ISingleInstanceProvider<>));

                var contractType = Enumerable.First(MemberType.GetGenericArguments());

                type = _optional ? typeof(OptionalSingleInstanceProvider<>).MakeGenericType(contractType) : typeof(SingleInstanceProvider<>).MakeGenericType(contractType);

            }

            return (IInjectionValue)Activator.CreateInstance(type);

        }

        private bool _shared;

        private bool _optional;

    }

    class MultipleInstancesInjectionTarget : AbstractInjectionTarget

    {

        public MultipleInstancesInjectionTarget(bool shared, bool optional, MemberInfo member)

            : base(member)

        {

            _shared = shared;

            _optional = optional;

        }

        protected override IInjectionValue DoGetInjectionValue(Type callingType)

        {

            Type type;

            if (_shared)

            {

                if (!IsOfGenericType(MemberType, typeof(ISharedMultipleInstancesProvider<>)))

                    throw new WrongMemberTypeForInjectionException(Member, typeof(ISharedMultipleInstancesProvider<>));

                var contractType = Enumerable.First(MemberType.GetGenericArguments());

                type = _optional ? typeof(OptionalSharedMultipleInstancesProvider<>).MakeGenericType(contractType) : typeof(SharedMultipleInstancesProvider<>).MakeGenericType(contractType);

            }

            else

            {

                if (!IsOfGenericType(MemberType, typeof(IMultipleInstancesProvider<>)))

                    throw new WrongMemberTypeForInjectionException(Member, typeof(IMultipleInstancesProvider<>));

                var contractType = Enumerable.First(MemberType.GetGenericArguments());

                type = _optional ? typeof(OptionalMultipleInstancesProvider<>).MakeGenericType(contractType) : typeof(MultipleInstancesProvider<>).MakeGenericType(contractType);

            }

            return (IInjectionValue)Activator.CreateInstance(type);

        }

        private bool _shared;

        private bool _optional;

    }

    class SpecificInstanceInjectionTarget : AbstractInjectionTarget

    {

        public SpecificInstanceInjectionTarget(Guid typeGuid, bool shared, bool optional, MemberInfo member)

            : base(member)

        {

            _typeGuid = typeGuid;

            _shared = shared;

            _optional = optional;

        }

        protected override IInjectionValue DoGetInjectionValue(Type callingType)

        {

            Type type;

            if (_shared)

            {

                if (!IsOfGenericType(MemberType, typeof(ISharedSingleInstanceProvider<>)))

                    throw new WrongMemberTypeForInjectionException(Member, typeof(ISharedSingleInstanceProvider<>));

                var contractType = Enumerable.First(MemberType.GetGenericArguments());

                type = _optional ? typeof(OptionalSharedSpecificInstanceProvider<>).MakeGenericType(contractType) : typeof(SharedSpecificInstanceProvider<>).MakeGenericType(contractType);

            }

            else

            {

                if (!IsOfGenericType(MemberType, typeof(ISingleInstanceProvider<>)))

                    throw new WrongMemberTypeForInjectionException(Member, typeof(ISingleInstanceProvider<>));

                var contractType = Enumerable.First(MemberType.GetGenericArguments());

                type = _optional ? typeof(OptionalSpecificInstanceProvider<>).MakeGenericType(contractType) : typeof(SpecificInstanceProviderFallback<>).MakeGenericType(contractType);

            }

            var args = new object[] { _typeGuid };

            return (IInjectionValue)Activator.CreateInstance(type, args);

        }

        private Guid _typeGuid;

        private bool _shared;

        private bool _optional;

    }

    class AnyInstanceInjectionTarget : AbstractInjectionTarget

    {

        public AnyInstanceInjectionTarget(MemberInfo member)

            : base(member)

        {

        }

        protected override IInjectionValue DoGetInjectionValue(Type callingType)

        {

            if (!IsOfGenericType(MemberType, typeof(IAnyInstanceProvider<>)))

                throw new WrongMemberTypeForInjectionException(Member, typeof(IAnyInstanceProvider<>));

            var contractType = Enumerable.First(MemberType.GetGenericArguments());

            var type = typeof(AnyInstanceProvider<>).MakeGenericType(contractType);

            return (IInjectionValue)Activator.CreateInstance(type);

        }

    }

    class SpecificTypeInformationInjectionTarget : AbstractInjectionTarget

    {

        public SpecificTypeInformationInjectionTarget(Guid typeGuid, bool optional, MemberInfo member)

            : base(member)

        {

            _typeGuid = typeGuid;

            _optional = optional;

        }

        protected override IInjectionValue DoGetInjectionValue(Type callingType)

        {

            if (!typeof(ISpecificTypeInformation).IsAssignableFrom(MemberType))

                throw new WrongMemberTypeForInjectionException(Member, typeof(ISpecificTypeInformation));

            if (_optional)

                return new OptionalSpecificTypeInformation(_typeGuid);

            else

                return new SpecificTypeInformation(_typeGuid);

        }

        private Guid _typeGuid;

        private bool _optional;

    }

    class AnyTypeInformationInjectionTarget : AbstractInjectionTarget

    {

        public AnyTypeInformationInjectionTarget(MemberInfo member)

            : base(member)

        {

        }

        protected override IInjectionValue DoGetInjectionValue(Type callingType)

        {

            if (!typeof(IAnyTypeInformation).IsAssignableFrom(MemberType))

                throw new WrongMemberTypeForInjectionException(Member, typeof(IAnyTypeInformation));

            return new AnyTypeInformation();

        }

    }

    class ActiveProfileInjectionTarget : AbstractInjectionTarget

    {

        public ActiveProfileInjectionTarget(MemberInfo member)

            : base(member)

        {

        }

        protected override IInjectionValue DoGetInjectionValue(Type callingType)

        {

            if (!typeof(IProfileInformation).IsAssignableFrom(MemberType))

                throw new WrongMemberTypeForInjectionException(Member, typeof(IProfileInformation));

            return new ProfileInformation();

        }

    }

    class FrameFormInjectionTarget : AbstractInjectionTarget

    {

        public FrameFormInjectionTarget(MemberInfo member)

            : base(member)

        {

        }

        protected override IInjectionValue DoGetInjectionValue(Type callingType)

        {

            if (!typeof(IWinFormWrapperProxy).IsAssignableFrom(MemberType))

                throw new WrongMemberTypeForInjectionException(Member, typeof(IWinFormWrapperProxy));

            return new WinFormWrapperProxy();

        }

    }

    interface IInjectionValue

    {

        void Prepare(MemberInfo member, DependencyResolver dependencyResolver);

    }

    abstract class AbstractSingleInstanceProvider<TContract> : IInjectionValue where TContract : class

    {

        public abstract void Prepare(MemberInfo member, DependencyResolver dependencyResolver);

        public Guid TypeGuid

        {

            get { return _valueProvider.TypeGuid; }

        }

        protected void DoPrepare(MemberInfo member, bool optional, DependencyResolver dependencyResolver)

        {

            if (dependencyResolver == null)

                throw new ArgumentNullException(nameof(dependencyResolver));

            _valueProvider = dependencyResolver.ResolveSingle(typeof(TContract), optional, member);

        }

        protected TContract DoCreate()

        {

            return _valueProvider.CreateInstance<TContract>();

        }

        private IValueProvider _valueProvider;

    }

    abstract class AbstractSharedSingleInstanceProvider<TContract> : AbstractSingleInstanceProvider<TContract>, ISharedSingleInstanceProvider<TContract> where TContract : class

    {

        public TContract Value

        {

            get

            {

                if (!_valueCreated)

                {

                    _value = DoCreate();

                    _valueCreated = true;

                }

                return _value;

            }

        }

        private TContract _value;

        private bool _valueCreated;

    }

    class SingleInstanceProvider<TContract> : AbstractSingleInstanceProvider<TContract>, ISingleInstanceProvider<TContract> where TContract : class

    {

        public override void Prepare(MemberInfo member, DependencyResolver depencencyResolver)

        {

            DoPrepare(member, false, depencencyResolver);

        }

        public TContract Create()

        {

            return DoCreate();

        }

    }

    class OptionalSingleInstanceProvider<TContract> : AbstractSingleInstanceProvider<TContract>, ISingleInstanceProvider<TContract> where TContract : class

    {

        public override void Prepare(MemberInfo member, DependencyResolver depencencyResolver)

        {

            DoPrepare(member, true, depencencyResolver);

        }

        public TContract Create()

        {

            return DoCreate();

        }

    }

    class SharedSingleInstanceProvider<TContract> : AbstractSharedSingleInstanceProvider<TContract> where TContract : class

    {

        public override void Prepare(MemberInfo member, DependencyResolver depencencyResolver)

        {

            DoPrepare(member, false, depencencyResolver);

        }

    }

    class OptionalSharedSingleInstanceProvider<TContract> : AbstractSharedSingleInstanceProvider<TContract> where TContract : class

    {

        public override void Prepare(MemberInfo member, DependencyResolver depencencyResolver)

        {

            DoPrepare(member, true, depencencyResolver);

        }

    }

    abstract class AbstractMultipleInstancesProvider<TContract> : IInjectionValue where TContract : class

    {

        public abstract void Prepare(MemberInfo member, DependencyResolver depencencyResolver);

        public IEnumerable<Guid> TypeGuids

        {

            get { return _valueProviders.Select(vp => vp.TypeGuid); }

        }

        protected void DoPrepare(MemberInfo member, bool optional, DependencyResolver dependencyResolver)

        {

            if (dependencyResolver == null)

                throw new ArgumentNullException(nameof(dependencyResolver));

            _valueProviders = dependencyResolver.ResolveMultiple(typeof(TContract), optional, member);

        }

        protected IEnumerable<TContract> DoCreate()

        {

            return _valueProviders.Select(vp => vp.CreateInstance<TContract>());

        }

        private IEnumerable<IValueProvider> _valueProviders;

    }

    abstract class AbstractSharedMultipleInstancesProvider<TContract> : AbstractMultipleInstancesProvider<TContract>, ISharedMultipleInstancesProvider<TContract> where TContract : class

    {

        public IEnumerable<TContract> Value

        {

            get

            {

                if (!_valueCreated)

                {

                    _value = Enumerable.ToList(DoCreate());

                    _valueCreated = true;

                }

                return _value;

            }

        }

        private List<TContract> _value;

        private bool _valueCreated;

    }

    class MultipleInstancesProvider<TContract> : AbstractMultipleInstancesProvider<TContract>, IMultipleInstancesProvider<TContract> where TContract : class

    {

        public override void Prepare(MemberInfo member, DependencyResolver depencencyResolver)

        {

            DoPrepare(member, false, depencencyResolver);

        }

        public IEnumerable<TContract> Create()

        {

            return Enumerable.ToList(DoCreate()); // If we would not call ToList(), every iteration over the enumerable would create new objects, which is likely not expected by the caller.

        }

        public TContract CreateFirst()

        {

            return Enumerable.First(DoCreate());

        }

    }

    class OptionalMultipleInstancesProvider<TContract> : AbstractMultipleInstancesProvider<TContract>, IMultipleInstancesProvider<TContract> where TContract : class

    {

        public override void Prepare(MemberInfo member, DependencyResolver depencencyResolver)

        {

            DoPrepare(member, true, depencencyResolver);

        }

        public IEnumerable<TContract> Create()

        {

            return Enumerable.ToList(DoCreate()); // If we would not call ToList(), every iteration over the enumerable would create new objects, which is likely not expected by the caller.

        }

        public TContract CreateFirst()

        {

            return Enumerable.FirstOrDefault(DoCreate());

        }

    }

    class SharedMultipleInstancesProvider<TContract> : AbstractSharedMultipleInstancesProvider<TContract> where TContract : class

    {

        public override void Prepare(MemberInfo member, DependencyResolver depencencyResolver)

        {

            DoPrepare(member, false, depencencyResolver);

        }

    }

    class OptionalSharedMultipleInstancesProvider<TContract> : AbstractSharedMultipleInstancesProvider<TContract> where TContract : class

    {

        public override void Prepare(MemberInfo member, DependencyResolver depencencyResolver)

        {

            DoPrepare(member, true, depencencyResolver);

        }

    }

    abstract class AbstractSpecificInstanceProvider<TContract> : IInjectionValue where TContract : class

    {

        protected AbstractSpecificInstanceProvider(Guid typeGuid)

        {

            _typeGuid = typeGuid;

        }

        public Guid TypeGuid

        {

            get { return _valueProvider.TypeGuid; }

        }

        public abstract void Prepare(MemberInfo member, DependencyResolver depencencyResolver);

        protected void DoPrepare(MemberInfo member, bool optional, DependencyResolver dependencyResolver)

        {

            if (dependencyResolver == null)

                throw new ArgumentNullException(nameof(dependencyResolver));

            _valueProvider = dependencyResolver.ResolveSpecific(_typeGuid, typeof(TContract), optional, member);

        }

        protected TContract DoCreate()

        {

            return _valueProvider.CreateInstance<TContract>();

        }

        private Guid _typeGuid;

        private IValueProvider _valueProvider;

    }

    abstract class AbstractSharedSpecificInstanceProvider<TContract> : AbstractSpecificInstanceProvider<TContract>, ISharedSingleInstanceProvider<TContract> where TContract : class

    {

        protected AbstractSharedSpecificInstanceProvider(Guid typeGuid)

            : base(typeGuid)

        {

        }

        public TContract Value

        {

            get

            {

                if (!_valueCreated)

                {

                    _value = DoCreate();

                    _valueCreated = true;

                }

                return _value;

            }

        }

        private TContract _value;

        private bool _valueCreated;

    }

    class SpecificInstanceProviderFallback<TContract> : AbstractSpecificInstanceProvider<TContract>, ISingleInstanceProvider<TContract> where TContract : class

    {

        public SpecificInstanceProviderFallback(Guid typeGuid)

            : base(typeGuid)

        {

        }

        public override void Prepare(MemberInfo member, DependencyResolver depencencyResolver)

        {

            DoPrepare(member, false, depencencyResolver);

        }

        public TContract Create()

        {

            return DoCreate();

        }

    }

    class OptionalSpecificInstanceProvider<TContract> : AbstractSpecificInstanceProvider<TContract>, ISingleInstanceProvider<TContract> where TContract : class

    {

        public OptionalSpecificInstanceProvider(Guid typeGuid)

            : base(typeGuid)

        {

        }

        public override void Prepare(MemberInfo member, DependencyResolver depencencyResolver)

        {

            DoPrepare(member, true, depencencyResolver);

        }

        public TContract Create()

        {

            return DoCreate();

        }

    }

    class SharedSpecificInstanceProvider<TContract> : AbstractSharedSpecificInstanceProvider<TContract> where TContract : class

    {

        public SharedSpecificInstanceProvider(Guid typeGuid)

            : base(typeGuid)

        {

        }

        public override void Prepare(MemberInfo member, DependencyResolver depencencyResolver)

        {

            DoPrepare(member, false, depencencyResolver);

        }

    }

    class OptionalSharedSpecificInstanceProvider<TContract> : AbstractSharedSpecificInstanceProvider<TContract> where TContract : class

    {

        public OptionalSharedSpecificInstanceProvider(Guid typeGuid)

            : base(typeGuid)

        {

        }

        public override void Prepare(MemberInfo member, DependencyResolver depencencyResolver)

        {

            DoPrepare(member, true, depencencyResolver);

        }

    }

    class AnyInstanceProvider<TContract> : IAnyInstanceProvider<TContract>, IInjectionValue where TContract : class

    {

        public void Prepare(MemberInfo member, DependencyResolver depencencyResolver)

        {

            _member = member;

            _dependencyResolver = depencencyResolver;

        }

        public TContract Create(Guid typeGuid)

        {

            if (_dependencyResolver == null)

                throw new InvalidOperationException("The dependency resolver has not been set.");

            return _dependencyResolver.ResolveSpecific(typeGuid, typeof(TContract), false, _member).CreateInstance<TContract>();

        }

        public TContract TryCreate(Guid typeGuid)

        {

            if (_dependencyResolver == null)

                throw new InvalidOperationException("The dependency resolver has not been set.");

            return _dependencyResolver.ResolveSpecific(typeGuid, typeof(TContract), true, _member).CreateInstance<TContract>();

        }

        private MemberInfo _member;

        private DependencyResolver _dependencyResolver;

    }

    abstract class AbstractSpecificTypeInformation : ISpecificTypeInformation, IInjectionValue

    {

        protected AbstractSpecificTypeInformation(Guid typeGuid)

        {

            TypeGuid = typeGuid;

        }

        public abstract void Prepare(MemberInfo member, DependencyResolver depencencyResolver);

        public Guid TypeGuid { get; private set; }

        public Type Type { get; private set; }

        public TypeInformation TypeInformation { get; private set; }

        protected void DoPrepare(MemberInfo member, bool optional, DependencyResolver dependencyResolver)

        {

            if (dependencyResolver == null)

                throw new ArgumentNullException(nameof(dependencyResolver));

            try

            {

                var valueProvider = dependencyResolver.ResolveSpecific(TypeGuid, typeof(object), optional, member);

                Type = valueProvider.Type;

                TypeInformation = valueProvider.TypeInformation;

            }

            catch (NoInstanceForInjectionException ex)

            {

                // It is inconsistent compared to other injection to throw the exception

                // immediately within the DoPrepare() method (instead upon value retrieval by the

                // consumer), but the original implementation behaves likewise.

                throw new NoTypeInformationForInjectionException(ex.InjectionTarget);

            }

        }

    }

    class SpecificTypeInformation : AbstractSpecificTypeInformation

    {

        public SpecificTypeInformation(Guid typeGuid)

            : base(typeGuid)

        {

        }

        public override void Prepare(MemberInfo member, DependencyResolver depencencyResolver)

        {

            DoPrepare(member, false, depencencyResolver);

        }

    }

    class OptionalSpecificTypeInformation : AbstractSpecificTypeInformation

    {

        public OptionalSpecificTypeInformation(Guid typeGuid)

            : base(typeGuid)

        {

        }

        public override void Prepare(MemberInfo member, DependencyResolver depencencyResolver)

        {

            DoPrepare(member, true, depencencyResolver);

        }

    }

    class AnyTypeInformation : IAnyTypeInformation, IInjectionValue

    {

        public void Prepare(MemberInfo member, DependencyResolver depencencyResolver)

        {

            _member = member;

            _dependencyResolver = depencencyResolver;

        }

        public Type GetType(Guid typeGuid)

        {

            if (_dependencyResolver == null)

                throw new ArgumentNullException(nameof(_dependencyResolver));

            return _dependencyResolver.ResolveSpecific(typeGuid, typeof(object), false, _member).Type;

        }

        public Type TryGetType(Guid typeGuid)

        {

            if (_dependencyResolver == null)

                throw new ArgumentNullException(nameof(_dependencyResolver));

            return _dependencyResolver.ResolveSpecific(typeGuid, typeof(object), true, _member).Type;

        }

        public TypeInformation GetTypeInformation(Guid typeGuid)

        {

            if (_dependencyResolver == null)

                throw new ArgumentNullException(nameof(_dependencyResolver));

            return _dependencyResolver.ResolveSpecific(typeGuid, typeof(object), false, _member).TypeInformation;

        }

        public TypeInformation TryGetTypeInformation(Guid typeGuid)

        {

            if (_dependencyResolver == null)

                throw new ArgumentNullException(nameof(_dependencyResolver));

            return _dependencyResolver.ResolveSpecific(typeGuid, typeof(object), true, _member).TypeInformation;

        }

        private MemberInfo _member;

        private DependencyResolver _dependencyResolver;

    }

    class ProfileInformation : IProfileInformation, IInjectionValue

    {

        public void Prepare(MemberInfo member, DependencyResolver depencencyResolver)

        {

            if (depencencyResolver == null)

                throw new ArgumentNullException(nameof(depencencyResolver));

            string profileName;

            Profile profile;

            depencencyResolver.ResolveProfile(member, out profileName, out profile);

            ProfileName = profileName;

            Profile = profile;

        }

        public string ProfileName { get; private set; }

        public Profile Profile { get; private set; }

    }

    class WinFormWrapperProxy : IWinFormWrapperProxy, IInjectionValue

    {

        public IWinFormWrapper FrameForm { get; private set; }

        public void Prepare(MemberInfo member, DependencyResolver depencencyResolver)

        {

            if (depencencyResolver == null)

                throw new ArgumentNullException(nameof(depencencyResolver));

            FrameForm = depencencyResolver.ResolveFrameForm(member);

        }

    }

}