Merge branch 'master' of https://github.com/ninject/ninject

Author: iappert

src/Ninject/Activation/Providers/StandardProvider.cs

@@ -77,22 +77,32 @@ public virtual object Create(IContext context)
                 context.Plan = this.Planner.GetPlan(this.GetImplementationType(context.Request.Service));
             }
 
-            if (!context.Plan.Has<ConstructorInjectionDirective>())
+            ConstructorInjectionDirective directive = null;
+            var directives = context.Plan.ConstructorInjectionDirectives;
+
+            if (directives.Count == 1)
             {
-                throw new ActivationException(ExceptionFormatter.NoConstructorsAvailable(context));
+                directive = directives[0];
             }
-
-            var directives = context.Plan.GetAll<ConstructorInjectionDirective>();
-            var bestDirectives = directives
-                .GroupBy(option => this.ConstructorScorer.Score(context, option))
-                .OrderByDescending(g => g.Key)
-                .First();
-            if (bestDirectives.Skip(1).Any())
+            else
             {
-                throw new ActivationException(ExceptionFormatter.ConstructorsAmbiguous(context, bestDirectives));
+                var bestDirectives = directives
+                      .GroupBy(option => this.ConstructorScorer.Score(context, option))
+                      .OrderByDescending(g => g.Key)
+                      .FirstOrDefault();
+                if (bestDirectives == null)
+                {
+                    throw new ActivationException(ExceptionFormatter.NoConstructorsAvailable(context));
+                }
+
+                if (bestDirectives.Skip(1).Any())
+                {
+                    throw new ActivationException(ExceptionFormatter.ConstructorsAmbiguous(context, bestDirectives));
+                }
+
+                directive = bestDirectives.First();
             }
 
-            var directive = bestDirectives.Single();
             var arguments = directive.Targets.Select(target => this.GetValue(context, target)).ToArray();
             return directive.Injector(arguments);
         }

src/Ninject/Planning/Directives/ConstructorInjectionDirective.cs

@@ -26,6 +26,12 @@ public class ConstructorInjectionDirective : MethodInjectionDirectiveBase<Constr
         /// </summary>
         public ConstructorInfo Constructor { get; set; }
 
+        /// <summary>
+        /// Gets or sets a value indicating whether this constructor has an inject attribute.
+        /// </summary>
+        /// <value><c>true</c> if this constructor has an inject attribute; otherwise, <c>false</c>.</value>
+        public bool HasInjectAttribute { get; set; }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="ConstructorInjectionDirective"/> class.
         /// </summary>

src/Ninject/Planning/IPlan.cs

@@ -25,6 +25,12 @@ public interface IPlan
         /// </summary>
         Type Type { get; }
 
+        /// <summary>
+        /// Gets the constructor injection directives.
+        /// </summary>
+        /// <value>The constructor injection directives.</value>
+        IList<ConstructorInjectionDirective> ConstructorInjectionDirectives { get; }
+
         /// <summary>
         /// Adds the specified directive to the plan.
         /// </summary>

src/Ninject/Planning/Plan.cs

@@ -32,6 +32,12 @@ public class Plan : IPlan
         /// </summary>
         public ICollection<IDirective> Directives { get; private set; }
 
+        /// <summary>
+        /// Gets the constructor injection directives.
+        /// </summary>
+        /// <value>The constructor injection directives.</value>
+        public IList<ConstructorInjectionDirective> ConstructorInjectionDirectives { get; private set; }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="Plan"/> class.
         /// </summary>
@@ -42,6 +48,7 @@ public Plan(Type type)
 
             Type = type;
             Directives = new List<IDirective>();
+            ConstructorInjectionDirectives = new List<ConstructorInjectionDirective>();
         }
 
         /// <summary>
@@ -51,6 +58,13 @@ public Plan(Type type)
         public void Add(IDirective directive)
         {
             Ensure.ArgumentNotNull(directive, "directive");
+
+            var constructorInjectionDirective = directive as ConstructorInjectionDirective;
+            if (constructorInjectionDirective != null)
+            {
+                ConstructorInjectionDirectives.Add(constructorInjectionDirective);
+            }
+
             Directives.Add(directive);
         }
 
@@ -62,7 +76,7 @@ public void Add(IDirective directive)
         public bool Has<TDirective>()
             where TDirective : IDirective
         {
-            return GetAll<TDirective>().Count() > 0;
+            return GetAll<TDirective>().Any();
         }
 
         /// <summary>

src/Ninject/Planning/Strategies/ConstructorReflectionStrategy.cs

@@ -13,6 +13,7 @@
 using System.Reflection;
 using Ninject.Components;
 using Ninject.Infrastructure;
+using Ninject.Infrastructure.Language;
 using Ninject.Injection;
 using Ninject.Planning.Directives;
 using Ninject.Selection;
@@ -64,7 +65,12 @@ public void Execute(IPlan plan)
 
             foreach(ConstructorInfo constructor in constructors)
             {
-                plan.Add(new ConstructorInjectionDirective(constructor, InjectorFactory.Create(constructor)));
+                var hasInjectAttribute = constructor.HasAttribute(Settings.InjectAttribute);
+                plan.Add(
+                    new ConstructorInjectionDirective(constructor, InjectorFactory.Create(constructor))
+                    {
+                        HasInjectAttribute = hasInjectAttribute
+                    });
             }
         }
     }

src/Ninject/Selection/Heuristics/StandardConstructorScorer.cs

@@ -52,7 +52,7 @@ public virtual int Score(IContext context, ConstructorInjectionDirective directi
             Ensure.ArgumentNotNull(context, "context");
             Ensure.ArgumentNotNull(directive, "constructor");
 
-            if (directive.Constructor.HasAttribute(Settings.InjectAttribute))
+            if (directive.HasInjectAttribute)
             {
                 return int.MaxValue;
             }