Example #1
0
        public static T Get <T>(this IResolutionRoot resolutionRoot)
        {
            var service  = typeof(T);
            var provider = resolutionRoot.ResolveProvider <T>();

            var request = new ResolveRequest(resolutionRoot.Root, service);

            return((T)provider.ResolveValue(request));
        }
Example #2
0
        public static void ResolveSingletons(this IResolutionRoot resolutionRoot)
        {
            var bindingsToResolve =
                resolutionRoot.Bindings.Where(binding => binding.Configuration.Provider is SingletoneBindingProvider);

            var toResolve = bindingsToResolve.ToList();

            if (!toResolve.Any())
            {
                return;
            }

            foreach (var binding in toResolve)
            {
                var request = new ResolveRequest(resolutionRoot.Root, binding.Service);
                binding.Configuration.Provider.ResolveValue(request);
            }
        }
Example #3
0
        public override object ResolveValue(IResolveRequest request)
        {
            if (!Contracts.Contains(request.Service))
            {
                return(null);
            }

            var constructors = Implementation.GetConstructors(BindingFlags.Instance | BindingFlags.Public);

            var constructor       = constructors.OrderBy(ct => ct.GetParameters().Length).First();
            var constructorParams = constructor.GetParameters().ToDictionary(pr => pr.Name, pr => pr.ParameterType);
            var bindings          = request.Root.RootBindings;

            if (!constructorParams.Any())
            {
                return(constructor.Invoke(null));
            }

            var parameters = new Dictionary <string, object>();

            foreach (var param in constructorParams)
            {
                if (bindings.All(bi => bi.Service != param.Value))
                {
                    throw new MissingConstructorParamException(request.Service, param.Key);
                }

                if (param.Value == request.Service)
                {
                    throw new CyclicDependencyException(param.Value, request.Service);
                }

                var binding            = bindings.First(bi => bi.Service == param.Value);
                var resolutionProvider = binding.Configuration.Provider;
                var resolutionRequest  = new ResolveRequest(request.Root, param.Value);

                parameters.Add(param.Key, resolutionProvider.ResolveValue(resolutionRequest));
            }

            var instance = constructor.Invoke(parameters.Values.ToArray());

            return(instance);
        }