Refactor implicits out of core injector logic. Partial add of qualifiers.

Author: iamahern

IfInjector/IfInjector.csproj

@@ -91,6 +91,7 @@ Distinguishing features are small size, speed and attribute based configuration.
     <Compile Include="source\Resolver\IBindingResolver.cs" />
     <Compile Include="source\Resolver\GenericBindingResolver.cs" />
     <Compile Include="source\Resolver\ImplicitBindingResolver.cs" />
+    <Compile Include="source\Bindings\Config\BindingAttributeUtils.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath32)\Microsoft\Portable\$(TargetFrameworkVersion)\Microsoft.Portable.CSharp.targets" />
   <ItemGroup>

IfInjector/TODO.txt

@@ -2,9 +2,6 @@
 	- Need for IDisposable???
 	- Implicit injection rules:
 		- Auto initialize types need error checking
-	- Upcast bindings:
-		- For iFace / concrete bindings - implicit bind concrete type?
-			=> probably not: issue is that it would break 'decorators' feature
 
 - KEY MISSING FEATURES:
 	- Decorators
@@ -17,7 +14,6 @@
 - TESTING:
 	- Add platform tests for Android, iPhone
 	- Need tests for error conditions in implicit bindings
-	- Replace benchmarks with IoCPerformance suite
 
 - WISH LIST:
 	- Extension feature to allow for interceptors

IfInjector/source/Bindings/Config/BindingAttributeUtils.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Linq;
+
+namespace IfInjector.Bindings.Config
+{
+	internal static class BindingAttributeUtils
+	{
+		/// <summary>
+		/// Gets if implemented by.
+		/// </summary>
+		/// <returns>The if implemented by.</returns>
+		/// <param name="bindingType">Binding type.</param>
+		internal static Type GetImplementedBy(Type bindingType) {
+			var implTypeAttr = bindingType.GetCustomAttributes(typeof(ImplementedByAttribute), false).FirstOrDefault();
+			if (implTypeAttr != null) {
+				return (implTypeAttr as ImplementedByAttribute).Implementor;
+			}
+
+			return null;
+		}
+	}
+}
+

IfInjector/source/Bindings/Config/BindingKey.cs

@@ -24,12 +24,14 @@ internal class BindingKey : IEquatable<BindingKey> {
 		private const int HASHCODE_MULTIPLIER = 33;
 
 		private readonly Type bindingType;
-		private readonly bool member;
+		private readonly bool isMember;
+		private readonly bool isImplicit;
 		private readonly string qualifier;
 
-		protected BindingKey(Type bindingType, bool member, string qualifier) {
+		protected BindingKey(Type bindingType, bool isMember, bool isImplicit, string qualifier) {
 			this.bindingType = bindingType;
-			this.member = member;
+			this.isMember = isMember;
+			this.isImplicit = isImplicit;
 			this.qualifier = (qualifier == null) ? NoQualifierValue : qualifier;
 		}
 
@@ -47,9 +49,19 @@ public Type BindingType {
 		/// Gets a value indicating whether this <see cref="IfInjector.IfBinding.BindingKey"/> is a property-only binding.
 		/// </summary>
 		/// <value><c>true</c> if member; otherwise, <c>false</c>.</value>
-		public bool Member {
+		public bool IsMember {
 			get {
-				return member;
+				return isMember;
+			}
+		}
+
+		/// <summary>
+		/// Gets a value indicating whether this instance is implicit. This facet does not affect the key for equals or hashing purposes.
+		/// </summary>
+		/// <value><c>true</c> if this instance is implicit; otherwise, <c>false</c>.</value>
+		public bool IsImplicit {
+			get {
+				return isImplicit;
 			}
 		}
 
@@ -71,7 +83,7 @@ public string Qualifier {
 		/// </summary>
 		/// <returns>A hash code for this instance that is suitable for use in hashing algorithms and data structures such as a hash table.</returns>
 		public override int GetHashCode() {
-			return HASHCODE_MULTIPLIER * BindingType.GetHashCode () + Member.GetHashCode () + qualifier.GetHashCode();
+			return HASHCODE_MULTIPLIER * BindingType.GetHashCode () + IsMember.GetHashCode () + qualifier.GetHashCode();
 		}
 
 		/// <summary>
@@ -97,57 +109,72 @@ public bool Equals(BindingKey obj) {
 				return true;
 			} else {
 				return bindingType.Equals (obj.bindingType) &&
-					member == obj.member &&
+					isMember == obj.isMember &&
 					qualifier.Equals(obj.qualifier);
 			}
 		}
 
 		/// <summary>
-		/// Get the instance injector.
+		/// Get the implicit version of the current binding key.
 		/// </summary>
-		/// <param name="keyType">Key type.</param>
-		internal static BindingKey Get(Type keyType) {
-			return Get (keyType, null);
+		/// <returns>The implicit.</returns>
+		internal BindingKey ToImplicit() {
+			if (IsImplicit) {
+				return this;
+			}
+
+			return new BindingKey (
+				bindingType: BindingType,
+				isMember: IsMember,
+				isImplicit: true,
+				qualifier: Qualifier);
 		}
 
 		/// <summary>
 		/// Gets a key.
 		/// </summary>
 		/// <returns>The internal.</returns>
-		/// <param name="keyType">Key type.</param>
+		/// <param name="bindingType">bindingType.</param>
 		/// <param name="isMember">If set to <c>true</c> is member.</param>
-		internal static BindingKey Get(Type keyType, bool isMember) {
-			return new BindingKey (keyType, isMember, null);
+		/// <param name="qualifier">Qualifier.</param>
+		internal static BindingKey Get(Type bindingType, string qualifier = null) {
+			return new BindingKey (
+				bindingType: bindingType, 
+				isMember: false, 
+				isImplicit: false, 
+				qualifier: qualifier);
 		}
 
 		/// <summary>
-		/// Gets the internal.
+		/// Get the specified qualifier.
 		/// </summary>
-		/// <returns>The internal.</returns>
-		/// <param name="keyType">Key type.</param>
-		/// <param name="isMember">If set to <c>true</c> is member.</param>
 		/// <param name="qualifier">Qualifier.</param>
-		internal static BindingKey Get(Type keyType, string qualifier) {
-			return new BindingKey (keyType, false, qualifier);
+		/// <typeparam name="BType">The 1st type parameter.</typeparam>
+		internal static BindingKey Get<BType>(string qualifier = null) where BType : class {
+			return Get (typeof(BType), qualifier);
 		}
-	}
-
-	/// <summary>
-	/// Typed binding key.
-	/// </summary>
-	internal class BindingKey<BType> : BindingKey where BType : class {
-		internal static readonly BindingKey<BType> InstanceKey = new BindingKey<BType> (false, null);
-		internal static readonly BindingKey<BType> MembersKey = new BindingKey<BType> (true, null);
 
-		private BindingKey(bool member, string qualifier) : base(typeof(BType), member, qualifier) { }
+		/// <summary>
+		/// Gets a key.
+		/// </summary>
+		/// <returns>The internal.</returns>
+		/// <param name="concreteType">Concrete type.</param>
+		/// <param name="isMember">If set to <c>true</c> is member.</param>
+		internal static BindingKey GetMember(Type concreteType) {
+			return new BindingKey (
+				bindingType: concreteType, 
+				isMember: true, 
+				isImplicit: false, 
+				qualifier: null);
+		}
 
 		/// <summary>
-		/// Get the instance injector.
+		/// Gets the member key.
 		/// </summary>
-		/// <param name="keyType">Key type.</param>
-		/// <param name="qualifier">Qualifier.</param>
-		internal static BindingKey Get(string qualifier) {
-			return new BindingKey<BType> (false, qualifier);
+		/// <returns>The member.</returns>
+		/// <typeparam name="CType">The 1st type parameter.</typeparam>
+		internal static BindingKey GetMember<CType>() {
+			return GetMember (typeof(CType));
 		}
 	}
 }

IfInjector/source/Bindings/Fluent/Concrete/BoundBinding.cs

@@ -20,7 +20,7 @@ internal class BoundBinding<BType, CType> : IBoundBinding<BType, CType>, IBindin
 
 		internal BoundBinding() {
 			BindingConfig = new BindingConfig(typeof(CType));
-			BindingKey = BindingKey<BType>.InstanceKey;
+			BindingKey = BindingKey.Get<BType> ();
 		}
 
 		public IBoundBinding<BType, CType> SetLifestyle (Lifestyle lifestyle) {

IfInjector/source/Bindings/Fluent/Members/BoundMembersBinding.cs

@@ -17,7 +17,7 @@ internal class BoundMembersBinding<CType> : IBoundMembersBinding<CType>, IBindin
 
 		internal BoundMembersBinding() {
 			BindingConfig = new BindingConfig(typeof(CType));
-			BindingKey = BindingKey<CType>.MembersKey;
+			BindingKey = BindingKey.GetMember<CType>();
 		}
 
 		public IBoundMembersBinding<CType> InjectMember<TPropertyType> (Expression<Func<CType, TPropertyType>> memberExpression)