Renamed IsAssignableTo as it conflicts with system.

Author: eben-roux

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().GetTypesAssignableToAsync<SomeClass>()).Count(), Is.EqualTo(1));
-        Assert.That((await new ReflectionService().GetTypesAssignableToAsync<ISomeClass>()).Count(), Is.EqualTo(1));
+        Assert.That((await new ReflectionService().GetTypesAssignableToExpandedAsync<SomeClass>()).Count(), Is.EqualTo(1));
+        Assert.That((await new ReflectionService().GetTypesAssignableToExpandedAsync<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 => TypeExtensions.IsAssignableTo(o.GetType(), type)).Select(o => (T)o).ToList();
+        return Guard.AgainstNull(list).Where(o => o.GetType().IsAssignableToExpanded(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>> GetTypesAssignableToAsync(Type type);
-    Task<IEnumerable<Type>> GetTypesAssignableToAsync(Type type, Assembly assembly);
+    Task<IEnumerable<Type>> GetTypesAssignableToExpandedAsync(Type type);
+    Task<IEnumerable<Type>> GetTypesAssignableToExpandedAsync(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>> GetTypesAssignableToAsync(Type type)
+    public async Task<IEnumerable<Type>> GetTypesAssignableToExpandedAsync(Type type)
     {
         var result = new List<Type>();
 
         var assemblies = await this.GetAssembliesAsync().ConfigureAwait(false);
 
         foreach (var assembly in assemblies)
         {
-            var types = await GetTypesAssignableToAsync(type, assembly).ConfigureAwait(false);
+            var types = await GetTypesAssignableToExpandedAsync(type, assembly).ConfigureAwait(false);
 
             types.Where(candidate => result.Find(existing => existing == candidate) == null)
                 .ToList()
@@ -61,11 +61,11 @@ public async Task<IEnumerable<Type>> GetTypesAssignableToAsync(Type type)
         return result;
     }
 
-    public async Task<IEnumerable<Type>> GetTypesAssignableToAsync(Type type, Assembly assembly)
+    public async Task<IEnumerable<Type>> GetTypesAssignableToExpandedAsync(Type type, Assembly assembly)
     {
         Guard.AgainstNull(type);
 
-        return await Task.FromResult(Guard.AgainstNull(assembly).GetTypes().Where(item => TypeExtensions.IsAssignableTo(item, type) && !(item.IsInterface && item == type)).ToList());
+        return await Task.FromResult(Guard.AgainstNull(assembly).GetTypes().Where(item => item.IsAssignableToExpanded(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>> GetTypesAssignableToAsync<T>(this IReflectionService service)
+    public static async Task<IEnumerable<Type>> GetTypesAssignableToExpandedAsync<T>(this IReflectionService service)
     {
-        return await Guard.AgainstNull(service).GetTypesAssignableToAsync(typeof(T)).ConfigureAwait(false);
+        return await Guard.AgainstNull(service).GetTypesAssignableToExpandedAsync(typeof(T)).ConfigureAwait(false);
     }
 
-    public static async Task<IEnumerable<Type>> GetTypesAssignableToAsync<T>(this IReflectionService service, Assembly assembly)
+    public static async Task<IEnumerable<Type>> GetTypesAssignableToExpandedAsync<T>(this IReflectionService service, Assembly assembly)
     {
-        return await Guard.AgainstNull(service).GetTypesAssignableToAsync(typeof(T), assembly).ConfigureAwait(false);
+        return await Guard.AgainstNull(service).GetTypesAssignableToExpandedAsync(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 => IsAssignableTo(item, of));
+        return interfaces.FirstOrDefault(item => IsAssignableToExpanded(item, of));
     }
 
     public static Type? GetGenericArgument(this Type type, Type generic)
@@ -75,19 +75,19 @@ public static bool HasDefaultConstructor(this Type type)
         return null;
     }
 
-    public static IEnumerable<Type> InterfacesAssignableTo<T>(this Type type)
+    public static IEnumerable<Type> InterfacesAssignableToExpanded<T>(this Type type)
     {
-        return type.InterfacesAssignableTo(typeof(T));
+        return type.InterfacesAssignableToExpanded(typeof(T));
     }
 
-    public static IEnumerable<Type> InterfacesAssignableTo(this Type type, Type interfaceType)
+    public static IEnumerable<Type> InterfacesAssignableToExpanded(this Type type, Type interfaceType)
     {
         Guard.AgainstNull(interfaceType);
 
-        return type.GetInterfaces().Where(i => IsAssignableTo(i, interfaceType)).ToList();
+        return type.GetInterfaces().Where(i => IsAssignableToExpanded(i, interfaceType)).ToList();
     }
 
-    public static bool IsAssignableTo(this Type type, Type otherType)
+    public static bool IsAssignableToExpanded(this Type type, Type otherType)
     {
         Guard.AgainstNull(type);
         Guard.AgainstNull(otherType);