Merge pull request #4 from Shuttle/async

Async

Author: eben-roux

README.md

@@ -15,52 +15,47 @@ string AssemblyPath(Assembly assembly)
 Returns the path to the given assembly.
 
 ``` c#
-Assembly FindAssemblyNamed(string name)
+Task<Assembly> FindAssemblyNamedAsync(string name)
 ```
 
 Returns the `Assembly` that has the requested `name`; else `null`.
 
 ``` c#
-Assembly GetAssembly(string assemblyPath)
+Task<Assembly> GetAssemblyAsync(string assemblyPath)
 ```
 
 Returns the requested assembly if found; else `null`.
 
-```c#
-IEnumerable<Assembly> GetAssemblies()
-```
-
-Returns all reachable assemblies.
-
 ``` c#
-IEnumerable<Assembly> GetMatchingAssemblies(string regex)
+Task<IEnumerable<Assembly>> GetMatchingAssembliesAsync(Regex regex)
 ```
 
 Returns a collection of assemblies that have their file name matching the given `Regex` expression.
 
 ``` c#
-IEnumerable<Assembly> GetRuntimeAssemblies()
+Task<IEnumerable<Assembly>> GetRuntimeAssembliesAsync()
 ```
 
-For .Net 4.6+ returns `AppDomain.CurrentDomain.GetAssemblies();`.  For .Net Core 2.0+ all the `DependencyContext.Default.GetRuntimeAssemblyNames(RuntimeEnvironment.GetRuntimeIdentifier())` assembly names are resolved.
+For .Net 4.6+ (which isn't support in the latest version) returns `AppDomain.CurrentDomain.GetAssemblies();`.  For .Net Core 2.0+ all the `DependencyContext.Default.GetRuntimeAssemblyNames(RuntimeEnvironment.GetRuntimeIdentifier())` assembly names are resolved.
 
 ``` c#
-Type GetType(string typeName)
+Task<Type> GetTypeAsync(string typeName)
 ```
 
 Attempts to find the requested type.
 
 ``` c#
-IEnumerable<Type> GetTypes(Assembly assembly)
+Task<IEnumerable<Type>> GetTypesAsync(Assembly assembly)
 ```
 
 Returns all types in the given `assembly`.
 
 ``` c#
-IEnumerable<Type> GetTypesAssignableTo<T>();
-IEnumerable<Type> GetTypesAssignableTo(Type type);
-IEnumerable<Type> GetTypesAssignableTo<T>(Assembly assembly);
-IEnumerable<Type> GetTypesAssignableTo(Type type, Assembly assembly);
+Task<IEnumerable<Type>> GetTypesAssignableToAsync(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);
 ```
 
 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

@@ -1,6 +1,7 @@
 using System;
 using System.Linq;
 using System.Reflection;
+using System.Threading.Tasks;
 using NUnit.Framework;
 
 namespace Shuttle.Core.Reflection.Tests
@@ -14,24 +15,49 @@ public void Should_be_able_to_get_runtime_assemblies()
             Assert.That(new ReflectionService().GetRuntimeAssemblies().Count(), Is.GreaterThan(0));
         }
 
+        [Test]
+        public async Task Should_be_able_to_get_runtime_assemblies_async()
+        {
+            Assert.That((await new ReflectionService().GetRuntimeAssembliesAsync()).Count(), Is.GreaterThan(0));
+        }
+
         [Test]
         public void Should_be_able_to_get_types()
         {
             Assert.That(new ReflectionService().GetTypesAssignableTo<SomeClass>().Count(), Is.EqualTo(1));
             Assert.That(new ReflectionService().GetTypesAssignableTo<ISomeClass>().Count(), Is.EqualTo(1));
         }
 
+        [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));
+        }
+
         [Test]
         public void Should_be_able_to_get_matching_assemblies()
         {
             var service = new ReflectionService();
-            
+
             Assert.That(service.GetMatchingAssemblies(".+").Count(), Is.GreaterThan(0));
 
             foreach (var assembly in service.GetMatchingAssemblies("nunit"))
             {
                 Assert.That(assembly.FullName.Contains("nunit"));
             }
         }
+
+        public async Task Should_be_able_to_get_matching_assemblies_async()
+        {
+            var service = new ReflectionService();
+            
+            Assert.That((await service.GetMatchingAssembliesAsync(".+")).Count(), Is.GreaterThan(0));
+
+            foreach (var assembly in (await service.GetMatchingAssembliesAsync("nunit")))
+            {
+                Assert.That(assembly.FullName.Contains("nunit"));
+            }
+        }
     }
 }

Shuttle.Core.Reflection.Tests/Shuttle.Core.Reflection.Tests.csproj

@@ -5,9 +5,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.0" />
-    <PackageReference Include="NUnit" Version="3.13.3" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.3.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="NUnit" Version="3.14.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
   </ItemGroup>
 
   <ItemGroup>

Shuttle.Core.Reflection/.package/package.nuspec

@@ -3,7 +3,7 @@
 <package>
 	<metadata>
 		<id>Shuttle.Core.Reflection</id>
-		<version>12.0.1</version>
+		<version>13.0.0</version>
 		<authors>Eben Roux</authors>
 		<owners>Eben Roux</owners>
 		<license type="expression">BSD-3-Clause</license>
@@ -13,11 +13,11 @@
 		<repository type="git" url="https://github.com/shuttle/Shuttle.Core.Reflection.git" />
 		<projectUrl>https://github.com/shuttle/Shuttle.Core.Reflection</projectUrl>
 		<description>Reflection infrastructure components.</description>
-		<copyright>Copyright (c) 2022, Eben Roux</copyright>
+		<copyright>Copyright (c) 2024, Eben Roux</copyright>
 		<tags>shuttle reflection</tags>
 		<dependencies>
       <dependency id="Microsoft.Extensions.DependencyModel" version="7.0.0" />
-      <dependency id="Shuttle.Core.Contract" version="11.0.0" />
+      <dependency id="Shuttle.Core.Contract" version="11.1.0" />
 		</dependencies>
 	</metadata>
 	<files>

Shuttle.Core.Reflection/IReflectionService.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Reflection;
 using System.Text.RegularExpressions;
+using System.Threading.Tasks;
 
 namespace Shuttle.Core.Reflection
 {
@@ -10,6 +11,7 @@ public interface IReflectionService
         event EventHandler<ExceptionRaisedEventArgs> ExceptionRaised;
 
         string AssemblyPath(Assembly assembly);
+
         Assembly GetAssembly(string assemblyPath);
         Assembly FindAssemblyNamed(string name);
         IEnumerable<Assembly> GetMatchingAssemblies(Regex regex);
@@ -18,5 +20,14 @@ public interface IReflectionService
         IEnumerable<Type> GetTypesAssignableTo(Type type, Assembly assembly);
         Type GetType(string typeName);
         IEnumerable<Assembly> GetRuntimeAssemblies();
+
+        Task<Assembly> GetAssemblyAsync(string assemblyPath);
+        Task<Assembly> FindAssemblyNamedAsync(string name);
+        Task<IEnumerable<Assembly>> GetMatchingAssembliesAsync(Regex regex);
+        Task<IEnumerable<Type>> GetTypesAssignableToAsync(Type type);
+        Task<IEnumerable<Type>> GetTypesAsync(Assembly assembly);
+        Task<IEnumerable<Type>> GetTypesAssignableToAsync(Type type, Assembly assembly);
+        Task<Type> GetTypeAsync(string typeName);
+        Task<IEnumerable<Assembly>> GetRuntimeAssembliesAsync();
     }
 }

Shuttle.Core.Reflection/ObjectExtensions.cs

@@ -1,15 +1,28 @@
 using System;
+using System.Threading.Tasks;
 
 namespace Shuttle.Core.Reflection
 {
     public static class ObjectExtensions
     {
-        public static void AttemptDispose(this object o)
+        public static void TryDispose(this object o)
         {
             if (o is IDisposable disposable)
             {
                 disposable.Dispose();
             }
         }
+
+        public static async Task TryDisposeAsync(this object o)
+        {
+            if (o is IAsyncDisposable disposable)
+            {
+                await disposable.DisposeAsync().ConfigureAwait(false);
+            }
+            else
+            {
+                o.TryDispose();
+            }
+        }
     }
 }

Shuttle.Core.Reflection/Properties/AssemblyInfo.cs

@@ -13,10 +13,10 @@
 [assembly: AssemblyTitle(".NET Standard")]
 #endif
 
-[assembly: AssemblyVersion("12.0.1.0")]
-[assembly: AssemblyCopyright("Copyright (c) 2022, Eben Roux")]
+[assembly: AssemblyVersion("13.0.0.0")]
+[assembly: AssemblyCopyright("Copyright (c) 2024, Eben Roux")]
 [assembly: AssemblyProduct("Shuttle.Core.Reflection")]
 [assembly: AssemblyCompany("Eben Roux")]
 [assembly: AssemblyConfiguration("Release")]
-[assembly: AssemblyInformationalVersion("12.0.1")]
+[assembly: AssemblyInformationalVersion("13.0.0")]
 [assembly: ComVisible(false)]