Renamed *IsAssignableTo to *IsCastableTo.

Author: eben-roux

README.md

@@ -27,11 +27,11 @@ Task<Type> GetTypeAsync(string typeName)
 Attempts to find the requested type.
 
 ``` c#
-Task<IEnumerable<Type>> GetTypesAssignableToAsync(Type type, Assembly assembly)
+Task<IEnumerable<Type>> GetTypesCastableToAsync(Type type, Assembly assembly)
 // and these extensions
-Task<IEnumerable<Type>> GetTypesAssignableToAsync<T>();
-Task<IEnumerable<Type>> GetTypesAssignableToAsync(Type type);
-Task<IEnumerable<Type>> GetTypesAssignableToAsync<T>(Assembly assembly);
+Task<IEnumerable<Type>> GetTypesCastableToAsync<T>();
+Task<IEnumerable<Type>> GetTypesCastableToAsync(Type type);
+Task<IEnumerable<Type>> GetTypesCastableToAsync<T>(Assembly assembly);
 ```
 
 Returns all the types in the given `assembly` that are assignable to the `type` or `typeof(T)`; if no `assembly` is provided the all assemblies returned by `GetAssemblies()` will be scanned.

Shuttle.Core.Reflection.Tests/ReflectionServiceFixture.cs

@@ -16,8 +16,8 @@ public async Task Should_be_able_to_get_runtime_assemblies_async()
     [Test]
     public async Task Should_be_able_to_get_types_async()
     {
-        Assert.That((await new ReflectionService().GetTypesAssignableToExpandedAsync<SomeClass>()).Count(), Is.EqualTo(1));
-        Assert.That((await new ReflectionService().GetTypesAssignableToExpandedAsync<ISomeClass>()).Count(), Is.EqualTo(1));
+        Assert.That((await new ReflectionService().GetTypesCastableToAsync<SomeClass>()).Count(), Is.EqualTo(1));
+        Assert.That((await new ReflectionService().GetTypesCastableToAsync<ISomeClass>()).Count(), Is.EqualTo(1));
     }
 
     public async Task Should_be_able_to_get_matching_assemblies_async()

Shuttle.Core.Reflection/EnumerableExtensions.cs

@@ -25,7 +25,7 @@ public static IEnumerable<T> FindAll<T>(this IEnumerable<object> list) where T :
     {
         var type = typeof(T);
 
-        return Guard.AgainstNull(list).Where(o => o.GetType().IsAssignableToExpanded(type)).Select(o => (T)o).ToList();
+        return Guard.AgainstNull(list).Where(o => o.GetType().IsCastableTo(type)).Select(o => (T)o).ToList();
     }
 
     public static T Get<T>(this IEnumerable<object> list) where T : class

Shuttle.Core.Reflection/IReflectionService.cs

@@ -11,6 +11,6 @@ public interface IReflectionService
     Task<IEnumerable<Assembly>> GetMatchingAssembliesAsync(Regex regex);
     Task<IEnumerable<Assembly>> GetRuntimeAssembliesAsync();
     Task<Type?> GetTypeAsync(string typeName);
-    Task<IEnumerable<Type>> GetTypesAssignableToExpandedAsync(Type type);
-    Task<IEnumerable<Type>> GetTypesAssignableToExpandedAsync(Type type, Assembly assembly);
+    Task<IEnumerable<Type>> GetTypesCastableToAsync(Type type);
+    Task<IEnumerable<Type>> GetTypesCastableToAsync(Type type, Assembly assembly);
 }

Shuttle.Core.Reflection/ReflectionService.cs

@@ -43,15 +43,15 @@ public async Task<IEnumerable<Assembly>> GetRuntimeAssembliesAsync()
         return await Task.FromResult(result);
     }
 
-    public async Task<IEnumerable<Type>> GetTypesAssignableToExpandedAsync(Type type)
+    public async Task<IEnumerable<Type>> GetTypesCastableToAsync(Type type)
     {
         var result = new List<Type>();
 
         var assemblies = await this.GetAssembliesAsync().ConfigureAwait(false);
 
         foreach (var assembly in assemblies)
         {
-            var types = await GetTypesAssignableToExpandedAsync(type, assembly).ConfigureAwait(false);
+            var types = await GetTypesCastableToAsync(type, assembly).ConfigureAwait(false);
 
             types.Where(candidate => result.Find(existing => existing == candidate) == null)
                 .ToList()
@@ -61,11 +61,11 @@ public async Task<IEnumerable<Type>> GetTypesAssignableToExpandedAsync(Type type
         return result;
     }
 
-    public async Task<IEnumerable<Type>> GetTypesAssignableToExpandedAsync(Type type, Assembly assembly)
+    public async Task<IEnumerable<Type>> GetTypesCastableToAsync(Type type, Assembly assembly)
     {
         Guard.AgainstNull(type);
 
-        return await Task.FromResult(Guard.AgainstNull(assembly).GetTypes().Where(item => item.IsAssignableToExpanded(type) && !(item.IsInterface && item == type)).ToList());
+        return await Task.FromResult(Guard.AgainstNull(assembly).GetTypes().Where(item => item.IsCastableTo(type) && !(item.IsInterface && item == type)).ToList());
     }
 
     public async Task<Type?> GetTypeAsync(string typeName)

Shuttle.Core.Reflection/ReflectionServiceExtensions.cs

@@ -20,13 +20,13 @@ public static async Task<IEnumerable<Assembly>> GetMatchingAssembliesAsync(this
         return await Guard.AgainstNull(service).GetMatchingAssembliesAsync(new(Guard.AgainstNullOrEmptyString(regex))).ConfigureAwait(false);
     }
 
-    public static async Task<IEnumerable<Type>> GetTypesAssignableToExpandedAsync<T>(this IReflectionService service)
+    public static async Task<IEnumerable<Type>> GetTypesCastableToAsync<T>(this IReflectionService service)
     {
-        return await Guard.AgainstNull(service).GetTypesAssignableToExpandedAsync(typeof(T)).ConfigureAwait(false);
+        return await Guard.AgainstNull(service).GetTypesCastableToAsync(typeof(T)).ConfigureAwait(false);
     }
 
-    public static async Task<IEnumerable<Type>> GetTypesAssignableToExpandedAsync<T>(this IReflectionService service, Assembly assembly)
+    public static async Task<IEnumerable<Type>> GetTypesCastableToAsync<T>(this IReflectionService service, Assembly assembly)
     {
-        return await Guard.AgainstNull(service).GetTypesAssignableToExpandedAsync(typeof(T), assembly).ConfigureAwait(false);
+        return await Guard.AgainstNull(service).GetTypesCastableToAsync(typeof(T), assembly).ConfigureAwait(false);
     }
 }

Shuttle.Core.Reflection/TypeExtensions.cs

@@ -36,7 +36,7 @@ public static void AssertDefaultConstructor(this Type type, string message)
             }
         }
 
-        return interfaces.FirstOrDefault(item => IsAssignableToExpanded(item, of));
+        return interfaces.FirstOrDefault(item => IsCastableTo(item, of));
     }
 
     public static Type? GetGenericArgument(this Type type, Type generic)
@@ -75,31 +75,31 @@ public static bool HasDefaultConstructor(this Type type)
         return null;
     }
 
-    public static IEnumerable<Type> InterfacesAssignableToExpanded<T>(this Type type)
+    public static IEnumerable<Type> InterfacesCastableTo<T>(this Type type)
     {
-        return type.InterfacesAssignableToExpanded(typeof(T));
+        return type.InterfacesCastableTo(typeof(T));
     }
 
-    public static IEnumerable<Type> InterfacesAssignableToExpanded(this Type type, Type interfaceType)
+    public static IEnumerable<Type> InterfacesCastableTo(this Type type, Type interfaceType)
     {
         Guard.AgainstNull(interfaceType);
 
-        return type.GetInterfaces().Where(i => IsAssignableToExpanded(i, interfaceType)).ToList();
+        return type.GetInterfaces().Where(i => IsCastableTo(i, interfaceType)).ToList();
     }
 
-    public static bool IsAssignableToExpanded(this Type type, Type otherType)
+    public static bool IsCastableTo(this Type type, Type otherType)
     {
         Guard.AgainstNull(type);
         Guard.AgainstNull(otherType);
 
         return type.IsGenericType && otherType.IsGenericType
             ? otherType.GetGenericTypeDefinition().IsAssignableFrom(type.GetGenericTypeDefinition())
             : otherType.IsGenericType
-                ? IsAssignableToGenericType(type, otherType)
+                ? IsCastableToGenericType(type, otherType)
                 : otherType.IsAssignableFrom(type);
     }
 
-    private static bool IsAssignableToGenericType(Type type, Type generic)
+    private static bool IsCastableToGenericType(Type type, Type generic)
     {
         return
             type.GetInterfaces()