Added If.IsAssignableFrom method, changed 'AsInterface' method name t…

…o 'As' name


git-tfs-id: [https://tfs.codeplex.com:443/tfs/TFS06]$/autoregistration;C33121

Tests.AutoRegistration/AutoRegistrationTests.cs

@@ -291,14 +291,15 @@ private void Example()
                 .IncludeAllLoadedAssemblies()
                 .ExcludeSystemAssemblies()
                 .ExcludeAssemblies(a => a.GetName().FullName.Contains("Test"))
+                .Include(If.ImplementsSingleInterface, Then.Register().AsSingleInterfaceOfType().UsingSingetonMode() )
                 .Include(If.Implements<ILogger>, Then.Register().UsingPerCallMode())
                 .Include(If.ImplementsITypeName, Then.Register().WithTypeName())
                 .Include(If.Implements<ICustomerRepository>, Then.Register().WithName("Sample"))
                 .Include(If.Implements<IOrderRepository>,
                          Then.Register().AsSingleInterfaceOfType().UsingPerCallMode())
                 .Include(If.DecoratedWith<LoggerAttribute>,
                          Then.Register()
-                             .AsInterface<IDisposable>()
+                             .As<IDisposable>()
                              .WithPartName(WellKnownAppParts.Logger)
                              .UsingLifetime<MyLifetimeManager>())
                 .Exclude(t => t.Name.Contains("Trace"))

Unity.AutoRegistration/IFluentRegistration.cs

@@ -83,21 +83,21 @@ public interface IFluentRegistration : IRegistrationOptions
         /// </summary>
         /// <typeparam name="TContact">The type of the interface.</typeparam>
         /// <returns>Fluent registration</returns>
-        IFluentRegistration AsInterface<TContact>() where TContact : class;
+        IFluentRegistration As<TContact>() where TContact : class;
 
         /// <summary>
-        /// Specifies interface resolver function that by given type returns interface register type as
+        /// Specifies interface or type resolver function that by given type returns type to register type as
         /// </summary>
-        /// <param name="interfaceResolver">Interface resolver.</param>
+        /// <param name="typeResolver">Interface resolver.</param>
         /// <returns>Fluent registration</returns>
-        IFluentRegistration AsInterface(Func<Type, Type> interfaceResolver);
+        IFluentRegistration As(Func<Type, Type> typeResolver);
 
         /// <summary>
-        /// Specifies interface resolver function that by given type returns interfaces register type as
+        /// Specifies interface or type resolver function that by given type returns types to register type as
         /// </summary>
-        /// <param name="interfacesResolver">Interface resolver.</param>
+        /// <param name="typesResolver">Interface resolver.</param>
         /// <returns>Fluent registration</returns>
-        IFluentRegistration AsInterface(Func<Type, Type[]> interfacesResolver);
+        IFluentRegistration As(Func<Type, Type[]> typesResolver);
 
         /// <summary>
         /// Specifies that type should be registered as its first interface

Unity.AutoRegistration/If.cs

@@ -116,6 +116,21 @@ public static bool Is<T>(this Type type)
             return type == typeof(T);
         }
 
+        /// <summary>
+        /// Determines whether type is assignable from specified type.
+        /// </summary>
+        /// <typeparam name="T">Generic method parameter type</typeparam>
+        /// <param name="type">Method argument type.</param>
+        /// <returns>
+        /// 	<c>true</c> if is assignable from the specified type; otherwise, <c>false</c>.
+        /// </returns>
+        public static bool IsAssignableFrom<T>(this Type type)
+        {
+            if (type == null)
+                throw new ArgumentNullException("type");
+            return type.IsAssignableFrom(typeof (T));
+        }
+
         /// <summary>
         /// Returns true for any assembly that is not null
         /// </summary>

Unity.AutoRegistration/RegistrationOptions.cs

@@ -210,7 +210,7 @@ public IFluentRegistration WithPartName(string name)
         /// </summary>
         /// <typeparam name="TContact">The type of the interface.</typeparam>
         /// <returns>Fluent registration</returns>
-        public IFluentRegistration AsInterface<TContact>() where TContact : class
+        public IFluentRegistration As<TContact>() where TContact : class
         {
             _interfacesToRegisterAsResolver = t => new List<Type> { typeof(TContact) };
             return this;
@@ -219,28 +219,28 @@ public IFluentRegistration AsInterface<TContact>() where TContact : class
         /// <summary>
         /// Specifies interface resolver function that by given type returns interface register type as
         /// </summary>
-        /// <param name="interfaceResolver">Interface resolver.</param>
+        /// <param name="typeResolver">Interface resolver.</param>
         /// <returns>Fluent registration</returns>
-        public IFluentRegistration AsInterface(Func<Type, Type> interfaceResolver)
+        public IFluentRegistration As(Func<Type, Type> typeResolver)
         {
-            if (interfaceResolver == null)
-                throw new ArgumentNullException("interfaceResolver");
+            if (typeResolver == null)
+                throw new ArgumentNullException("typeResolver");
 
-            _interfacesToRegisterAsResolver = t => new List<Type> {interfaceResolver(t)};
+            _interfacesToRegisterAsResolver = t => new List<Type> {typeResolver(t)};
             return this;
         }
 
         /// <summary>
         /// Specifies interface resolver function that by given type returns interfaces register type as
         /// </summary>
-        /// <param name="interfacesResolver">Interface resolver.</param>
+        /// <param name="typesResolver">Interface resolver.</param>
         /// <returns>Fluent registration</returns>
-        public IFluentRegistration AsInterface(Func<Type, Type[]> interfacesResolver)
+        public IFluentRegistration As(Func<Type, Type[]> typesResolver)
         {
-            if (interfacesResolver == null)
-                throw new ArgumentNullException("interfacesResolver");
+            if (typesResolver == null)
+                throw new ArgumentNullException("typesResolver");
 
-            _interfacesToRegisterAsResolver = t => new List<Type> ( interfacesResolver(t) );
+            _interfacesToRegisterAsResolver = t => new List<Type> ( typesResolver(t) );
             return this;
         }