public IRegistration LookupType(Query targetType, ResolverContext context)
        {
            IRegistration registration = underlying.LookupType(targetType, context);
            if (registration != null)
            {
                return registration;
            }

            Type type = targetType.ServiceType;
            if (!type.IsInterface && !type.IsAbstract && targetType.Name == null)
            {
                lock (createdRegistrations)
                {
                    if (createdRegistrations.ContainsKey(type))
                        return createdRegistrations[type];
                    var reg = new Registration
                                  {
                                      Service = targetType.ServiceType,
                                      Implementor = targetType.ServiceType,
                                      Lifestyle = lifestyle
                                  };
                    createdRegistrations.Add(type, reg);
                    return reg;
                }
            }
            return null;
        }
예제 #2
0
 public virtual object CreateType(Query query, ResolverContext context)
 {
     //Need to create a deep copy of the Context to make splitting the graph possible
     var localContext = ResolverContext.CreateContextFromContext(context);
     var registration = FindSuitableImplementor(query, localContext);
     var retVal = registration.Lifestyle.Execute(() =>
                                        {
                                            var creationContext = GenerateCreationContext(registration, localContext);
                                            return activator.CreateInstance(creationContext);
                                        });
     return retVal;
 }
예제 #3
0
 public virtual IRegistration LookupType(Query query, ResolverContext context)
 {
     IList<IRegistration> localParents = new List<IRegistration>(context.UsedRegistrations);
     var registrations = componentStore.GetRegistrationsForService(query.ServiceType);
     if (query.Name != null)
     {
         var @default = registrations.SingleOrDefault(p => p.Name == query.Name);
         if (@default == null)
             throw new ServiceNotFoundException(query.ServiceType, query.Name);
         return @default;
     }
     var registration = SkipParents(registrations, localParents);
     if (registration == null)
         return null;
     context.ConsumeRegistration(registration);
     return registration;
 }
예제 #4
0
        public virtual CreationContext GenerateCreationContext(IRegistration registration, ResolverContext context)
        {
            var componentType = registration.Implementor;
            var constructors = componentType.GetConstructors()
                .OrderByDescending(p => p.GetParameters().Count());

            IList<DependencyMissingException> missingDependencies = new List<DependencyMissingException>();
            foreach (var info in constructors)
            {
                missingDependencies = new List<DependencyMissingException>();
                var parameters = info.GetParameters();
                if (parameters.Length == 0) //Fast way out.
                    return CreateReturnContext(componentType, null);

                IList<object> resolvedParameters = new List<object>();
                foreach (var parameter in parameters)
                {
                    string explicitDependencyName = null;
                    var parameterName = parameter.Name;
                    if (registration.Parameters.ContainsKey(parameterName))
                        explicitDependencyName = registration.Parameters[parameterName];
                    Type type = parameter.ParameterType;

                    try
                    {
                        var query = new Query {ServiceType = type, Name = explicitDependencyName};
                        resolvedParameters.Add(CreateType(query, context));
                    }
                    catch (ServiceNotFoundException exception)
                    {
                        missingDependencies.Add(new DependencyMissingException(exception.Message, registration.Service.Name));
                    }
                }
                if (resolvedParameters.Count == parameters.Length)
                    return CreateReturnContext(componentType, resolvedParameters.ToArray());
            }
            throw missingDependencies.First(); //TODO: Expose all missing dependencies
        }
예제 #5
0
 public virtual object CreateType(Query query)
 {
     return CreateType(query, new ResolverContext());
 }
예제 #6
0
 private IRegistration FindSuitableImplementor(Query query, ResolverContext context)
 {
     var suitableImplementor = componentLookup.LookupType(query, context);
     if (suitableImplementor == null)
         throw new ServiceNotFoundException(query.ServiceType);
     return suitableImplementor;
 }