- async

eben-roux · eben-roux · commit ceabe3d0ef2e · 2023-02-13T11:34:17.000+02:00
diff --git a/Shuttle.Core.Reflection.Tests/ReflectionServiceFixture.cs b/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
@@ -9,26 +10,26 @@ namespace Shuttle.Core.Reflection.Tests
     public class ReflectionServiceFixture
     {
         [Test]
-        public void Should_be_able_to_get_runtime_assemblies()
+        public async Task Should_be_able_to_get_runtime_assemblies()
         {
-            Assert.That(new ReflectionService().GetRuntimeAssemblies().Count(), Is.GreaterThan(0));
+            Assert.That((await new ReflectionService().GetRuntimeAssemblies()).Count(), Is.GreaterThan(0));
         }
 
         [Test]
-        public void Should_be_able_to_get_types()
+        public async Task 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));
+            Assert.That((await new ReflectionService().GetTypesAssignableTo<SomeClass>()).Count(), Is.EqualTo(1));
+            Assert.That((await new ReflectionService().GetTypesAssignableTo<ISomeClass>()).Count(), Is.EqualTo(1));
         }
 
         [Test]
-        public void Should_be_able_to_get_matching_assemblies()
+        public async Task Should_be_able_to_get_matching_assemblies()
         {
             var service = new ReflectionService();
             
-            Assert.That(service.GetMatchingAssemblies(".+").Count(), Is.GreaterThan(0));
+            Assert.That((await service.GetMatchingAssemblies(".+")).Count(), Is.GreaterThan(0));
 
-            foreach (var assembly in service.GetMatchingAssemblies("nunit"))
+            foreach (var assembly in (await service.GetMatchingAssemblies("nunit")))
             {
                 Assert.That(assembly.FullName.Contains("nunit"));
             }
diff --git a/Shuttle.Core.Reflection/.package/package.nuspec b/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,7 +13,7 @@
 		<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) 2023, Eben Roux</copyright>
 		<tags>shuttle reflection</tags>
 		<dependencies>
       <dependency id="Microsoft.Extensions.DependencyModel" version="7.0.0" />
diff --git a/Shuttle.Core.Reflection/IReflectionService.cs b/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,13 +11,13 @@ public interface IReflectionService
         event EventHandler<ExceptionRaisedEventArgs> ExceptionRaised;
 
         string AssemblyPath(Assembly assembly);
-        Assembly GetAssembly(string assemblyPath);
-        Assembly FindAssemblyNamed(string name);
-        IEnumerable<Assembly> GetMatchingAssemblies(Regex regex);
-        IEnumerable<Type> GetTypesAssignableTo(Type type);
-        IEnumerable<Type> GetTypes(Assembly assembly);
-        IEnumerable<Type> GetTypesAssignableTo(Type type, Assembly assembly);
-        Type GetType(string typeName);
-        IEnumerable<Assembly> GetRuntimeAssemblies();
+        Task<Assembly> GetAssembly(string assemblyPath);
+        Task<Assembly> FindAssemblyNamed(string name);
+        Task<IEnumerable<Assembly>> GetMatchingAssemblies(Regex regex);
+        Task<IEnumerable<Type>> GetTypesAssignableTo(Type type);
+        Task<IEnumerable<Type>> GetTypes(Assembly assembly);
+        Task<IEnumerable<Type>> GetTypesAssignableTo(Type type, Assembly assembly);
+        Task<Type> GetType(string typeName);
+        Task<IEnumerable<Assembly>> GetRuntimeAssemblies();
     }
 }
diff --git a/Shuttle.Core.Reflection/ObjectExtensions.cs b/Shuttle.Core.Reflection/ObjectExtensions.cs
@@ -4,7 +4,7 @@ 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)
             {
diff --git a/Shuttle.Core.Reflection/Properties/AssemblyInfo.cs b/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) 2023, 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)]
diff --git a/Shuttle.Core.Reflection/ReflectionService.cs b/Shuttle.Core.Reflection/ReflectionService.cs
@@ -4,6 +4,7 @@
 using System.Linq;
 using System.Reflection;
 using System.Text.RegularExpressions;
+using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyModel;
 using Shuttle.Core.Contract;
 
@@ -30,11 +31,11 @@ public string AssemblyPath(Assembly assembly)
                 : string.Empty;
         }
 
-        public Assembly GetAssembly(string assemblyPath)
+        public async Task<Assembly> GetAssembly(string assemblyPath)
         {
-            var result = GetRuntimeAssemblies()
-                .FirstOrDefault(assembly => AssemblyPath(assembly)
-                    .Equals(assemblyPath, StringComparison.InvariantCultureIgnoreCase));
+            var assemblies = await GetRuntimeAssemblies().ConfigureAwait(false);
+
+            var result = assemblies.FirstOrDefault(assembly => AssemblyPath(assembly).Equals(assemblyPath, StringComparison.InvariantCultureIgnoreCase));
 
             if (result != null)
             {
@@ -47,13 +48,13 @@ public Assembly GetAssembly(string assemblyPath)
             }
             catch (Exception ex)
             {
-                ExceptionRaised.Invoke(this, new ExceptionRaisedEventArgs($"GetAssembly({assemblyPath})",ex));
+                ExceptionRaised.Invoke(this, new ExceptionRaisedEventArgs($"GetAssembly({assemblyPath})", ex));
 
                 return null;
             }
         }
 
-        public Assembly FindAssemblyNamed(string name)
+        public async Task<Assembly> FindAssemblyNamed(string name)
         {
             Guard.AgainstNullOrEmptyString(name, nameof(name));
 
@@ -68,9 +69,10 @@ public Assembly FindAssemblyNamed(string name)
                 hasFileExtension = true;
             }
 
-            var result = GetRuntimeAssemblies()
-                .FirstOrDefault(assembly => assembly.GetName()
-                    .Name.Equals(assemblyName, StringComparison.InvariantCultureIgnoreCase));
+            var assemblies = await GetRuntimeAssemblies().ConfigureAwait(false);
+
+            var result = assemblies.FirstOrDefault(assembly => assembly.GetName()
+                .Name.Equals(assemblyName, StringComparison.InvariantCultureIgnoreCase));
 
             if (result != null)
             {
@@ -97,7 +99,7 @@ public Assembly FindAssemblyNamed(string name)
 
                 if (File.Exists(path))
                 {
-                    return GetAssembly(path);
+                    return await GetAssembly(path);
                 }
 
                 if (!privateBinPath.Equals(AppDomain.CurrentDomain.BaseDirectory))
@@ -106,27 +108,26 @@ public Assembly FindAssemblyNamed(string name)
 
                     if (File.Exists(path))
                     {
-                        return GetAssembly(path);
+                        return await GetAssembly(path);
                     }
                 }
             }
 
             return null;
         }
 
-        public IEnumerable<Assembly> GetMatchingAssemblies(Regex regex)
+        public async Task<IEnumerable<Assembly>> GetMatchingAssemblies(Regex regex)
         {
             Guard.AgainstNull(regex, nameof(regex));
 
-            var assemblies =
-                new List<Assembly>(GetRuntimeAssemblies().Where(assembly => regex.IsMatch(assembly.FullName)));
+            var result = (await GetRuntimeAssemblies().ConfigureAwait(false)).Where(assembly => regex.IsMatch(assembly.FullName)).ToList();
 
             foreach (
                 var assembly in
-                GetMatchingAssemblies(regex, AppDomain.CurrentDomain.BaseDirectory)
-                    .Where(assembly => assemblies.Find(candidate => candidate.Equals(assembly)) == null))
+                (await GetMatchingAssemblies(regex, AppDomain.CurrentDomain.BaseDirectory).ConfigureAwait(false))
+                .Where(assembly => result.Find(candidate => candidate.Equals(assembly)) == null))
             {
-                assemblies.Add(assembly);
+                result.Add(assembly);
             }
 
             var privateBinPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory,
@@ -136,25 +137,25 @@ var assembly in
             {
                 foreach (
                     var assembly in
-                    GetMatchingAssemblies(regex, privateBinPath)
-                        .Where(assembly => assemblies.Find(candidate => candidate.Equals(assembly)) == null))
+                    (await GetMatchingAssemblies(regex, privateBinPath).ConfigureAwait(false))
+                    .Where(assembly => result.Find(candidate => candidate.Equals(assembly)) == null))
                 {
-                    assemblies.Add(assembly);
+                    result.Add(assembly);
                 }
             }
 
-            return assemblies;
+            return result;
         }
 
-        public IEnumerable<Assembly> GetRuntimeAssemblies()
+        public async Task<IEnumerable<Assembly>> GetRuntimeAssemblies()
         {
             var result = new List<Assembly>();
             var dependencyContext = DependencyContext.Default;
 
             if (dependencyContext != null)
             {
                 foreach (var runtimeAssemblyName in dependencyContext.GetRuntimeAssemblyNames(Environment.OSVersion
-                    .Platform.ToString()))
+                             .Platform.ToString()))
                 {
                     result.Add(Assembly.Load(runtimeAssemblyName));
                 }
@@ -168,44 +169,49 @@ public IEnumerable<Assembly> GetRuntimeAssemblies()
                 }
             }
 
-            return result;
+            return await Task.FromResult(result);
         }
 
-        public IEnumerable<Type> GetTypesAssignableTo(Type type)
+        public async Task<IEnumerable<Type>> GetTypesAssignableTo(Type type)
         {
             var result = new List<Type>();
 
-            foreach (var assembly in this.GetAssemblies())
+            var assemblies = await this.GetAssemblies().ConfigureAwait(false);
+
+            foreach (var assembly in assemblies)
             {
-                GetTypesAssignableTo(type, assembly)
-                    .Where(candidate => result.Find(existing => existing == candidate) == null)
+                var types = await GetTypesAssignableTo(type, assembly).ConfigureAwait(false);
+
+                types.Where(candidate => result.Find(existing => existing == candidate) == null)
                     .ToList()
                     .ForEach(add => result.Add(add));
             }
 
             return result;
         }
 
-        public IEnumerable<Type> GetTypesAssignableTo(Type type, Assembly assembly)
+        public async Task<IEnumerable<Type>> GetTypesAssignableTo(Type type, Assembly assembly)
         {
             Guard.AgainstNull(type, nameof(type));
             Guard.AgainstNull(assembly, nameof(assembly));
 
-            return GetTypes(assembly).Where(candidate =>
+            var types = await GetTypes(assembly).ConfigureAwait(false);
+
+            return types.Where(candidate =>
                 candidate.IsAssignableTo(type) && !(candidate.IsInterface && candidate == type)).ToList();
         }
 
-        public Type GetType(string typeName)
+        public async Task<Type> GetType(string typeName)
         {
-            return Type.GetType(typeName,
+            return await Task.FromResult(Type.GetType(typeName,
                 assemblyName =>
                 {
                     Assembly assembly;
 
                     try
                     {
                         assembly = Assembly.LoadFrom(
-                            Path.Combine(string.IsNullOrEmpty(AppDomain.CurrentDomain.RelativeSearchPath) 
+                            Path.Combine(string.IsNullOrEmpty(AppDomain.CurrentDomain.RelativeSearchPath)
                                 ? AppDomain.CurrentDomain.BaseDirectory
                                 : AppDomain.CurrentDomain.RelativeSearchPath, $"{assemblyName.Name}.dll"));
                     }
@@ -219,45 +225,43 @@ public Type GetType(string typeName)
                 },
                 (assembly, typeNameSought, ignore) => assembly == null
                     ? Type.GetType(typeNameSought, false, ignore)
-                    : assembly.GetType(typeNameSought, false, ignore));
+                    : assembly.GetType(typeNameSought, false, ignore)));
         }
 
-        public IEnumerable<Type> GetTypes(Assembly assembly)
+        public async Task<IEnumerable<Type>> GetTypes(Assembly assembly)
         {
             Guard.AgainstNull(assembly, nameof(assembly));
 
-            Type[] types;
+            var types = Enumerable.Empty<Type>();
 
             try
             {
-                types = assembly.GetTypes();
+                types = assembly.GetTypes().ToList();
             }
             catch (Exception ex)
             {
                 ExceptionRaised.Invoke(this, new ExceptionRaisedEventArgs($"GetTypes({assembly.FullName})", ex));
-
-                return new List<Type>();
             }
 
-            return types;
+            return await Task.FromResult(types);
         }
 
-        private IEnumerable<Assembly> GetMatchingAssemblies(Regex expression, string folder)
+        private async Task<IEnumerable<Assembly>> GetMatchingAssemblies(Regex expression, string folder)
         {
             var result = new List<Assembly>();
 
             if (Directory.Exists(folder))
             {
-                result.AddRange(
+                result.AddRange(await Task.WhenAll(
                     Directory.GetFiles(folder, "*.exe")
                         .Where(file => expression.IsMatch(Path.GetFileNameWithoutExtension(file)))
                         .Select(GetAssembly)
-                        .Where(assembly => assembly != null));
-                result.AddRange(
+                        .Where(assembly => assembly != null)));
+                result.AddRange(await Task.WhenAll(
                     Directory.GetFiles(folder, "*.dll")
                         .Where(file => expression.IsMatch(Path.GetFileNameWithoutExtension(file)))
-                        .Select(GetAssembly)
-                        .Where(assembly => assembly != null));
+                        .Select(assemblyPath => GetAssembly(assemblyPath))
+                        .Where(assembly => assembly != null)));
             }
 
             return result;
diff --git a/Shuttle.Core.Reflection/ReflectionServiceExtensions.cs b/Shuttle.Core.Reflection/ReflectionServiceExtensions.cs

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Linq;`
`3`	`3`	`using System.Reflection;`
	`4`	`+using System.Threading.Tasks;`
`4`	`5`	`using NUnit.Framework;`
`5`	`6`
`6`	`7`	`namespace Shuttle.Core.Reflection.Tests`
`@@ -9,26 +10,26 @@ namespace Shuttle.Core.Reflection.Tests`
`9`	`10`	`public class ReflectionServiceFixture`
`10`	`11`	`{`
`11`	`12`	`[Test]`
`12`		`- public void Should_be_able_to_get_runtime_assemblies()`
	`13`	`+ public async Task Should_be_able_to_get_runtime_assemblies()`
`13`	`14`	`{`
`14`		`- Assert.That(new ReflectionService().GetRuntimeAssemblies().Count(), Is.GreaterThan(0));`
	`15`	`+ Assert.That((await new ReflectionService().GetRuntimeAssemblies()).Count(), Is.GreaterThan(0));`
`15`	`16`	`}`
`16`	`17`
`17`	`18`	`[Test]`
`18`		`- public void Should_be_able_to_get_types()`
	`19`	`+ public async Task Should_be_able_to_get_types()`
`19`	`20`	`{`
`20`		`- Assert.That(new ReflectionService().GetTypesAssignableTo<SomeClass>().Count(), Is.EqualTo(1));`
`21`		`- Assert.That(new ReflectionService().GetTypesAssignableTo<ISomeClass>().Count(), Is.EqualTo(1));`
	`21`	`+ Assert.That((await new ReflectionService().GetTypesAssignableTo<SomeClass>()).Count(), Is.EqualTo(1));`
	`22`	`+ Assert.That((await new ReflectionService().GetTypesAssignableTo<ISomeClass>()).Count(), Is.EqualTo(1));`
`22`	`23`	`}`
`23`	`24`
`24`	`25`	`[Test]`
`25`		`- public void Should_be_able_to_get_matching_assemblies()`
	`26`	`+ public async Task Should_be_able_to_get_matching_assemblies()`
`26`	`27`	`{`
`27`	`28`	`var service = new ReflectionService();`
`28`	`29`
`29`		`- Assert.That(service.GetMatchingAssemblies(".+").Count(), Is.GreaterThan(0));`
	`30`	`+ Assert.That((await service.GetMatchingAssemblies(".+")).Count(), Is.GreaterThan(0));`
`30`	`31`
`31`		`- foreach (var assembly in service.GetMatchingAssemblies("nunit"))`
	`32`	`+ foreach (var assembly in (await service.GetMatchingAssemblies("nunit")))`
`32`	`33`	`{`
`33`	`34`	`Assert.That(assembly.FullName.Contains("nunit"));`
`34`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ namespace Shuttle.Core.Reflection`
`4`	`4`	`{`
`5`	`5`	`public static class ObjectExtensions`
`6`	`6`	`{`
`7`		`- public static void AttemptDispose(this object o)`
	`7`	`+ public static void TryDispose(this object o)`
`8`	`8`	`{`
`9`	`9`	`if (o is IDisposable disposable)`
`10`	`10`	`{`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`using System.Linq;`
`5`	`5`	`using System.Reflection;`
`6`	`6`	`using System.Text.RegularExpressions;`
	`7`	`+using System.Threading.Tasks;`
`7`	`8`	`using Microsoft.Extensions.DependencyModel;`
`8`	`9`	`using Shuttle.Core.Contract;`
`9`	`10`
`@@ -30,11 +31,11 @@ public string AssemblyPath(Assembly assembly)`
`30`	`31`	`: string.Empty;`
`31`	`32`	`}`
`32`	`33`
`33`		`- public Assembly GetAssembly(string assemblyPath)`
	`34`	`+ public async Task<Assembly> GetAssembly(string assemblyPath)`
`34`	`35`	`{`
`35`		`- var result = GetRuntimeAssemblies()`
`36`		`- .FirstOrDefault(assembly => AssemblyPath(assembly)`
`37`		`- .Equals(assemblyPath, StringComparison.InvariantCultureIgnoreCase));`
	`36`	`+ var assemblies = await GetRuntimeAssemblies().ConfigureAwait(false);`
	`37`	`+`
	`38`	`+ var result = assemblies.FirstOrDefault(assembly => AssemblyPath(assembly).Equals(assemblyPath, StringComparison.InvariantCultureIgnoreCase));`
`38`	`39`
`39`	`40`	`if (result != null)`
`40`	`41`	`{`
`@@ -47,13 +48,13 @@ public Assembly GetAssembly(string assemblyPath)`
`47`	`48`	`}`
`48`	`49`	`catch (Exception ex)`
`49`	`50`	`{`
`50`		`- ExceptionRaised.Invoke(this, new ExceptionRaisedEventArgs($"GetAssembly({assemblyPath})",ex));`
	`51`	`+ ExceptionRaised.Invoke(this, new ExceptionRaisedEventArgs($"GetAssembly({assemblyPath})", ex));`
`51`	`52`
`52`	`53`	`return null;`
`53`	`54`	`}`
`54`	`55`	`}`
`55`	`56`
`56`		`- public Assembly FindAssemblyNamed(string name)`
	`57`	`+ public async Task<Assembly> FindAssemblyNamed(string name)`
`57`	`58`	`{`
`58`	`59`	`Guard.AgainstNullOrEmptyString(name, nameof(name));`
`59`	`60`
`@@ -68,9 +69,10 @@ public Assembly FindAssemblyNamed(string name)`
`68`	`69`	`hasFileExtension = true;`
`69`	`70`	`}`
`70`	`71`
`71`		`- var result = GetRuntimeAssemblies()`
`72`		`- .FirstOrDefault(assembly => assembly.GetName()`
`73`		`- .Name.Equals(assemblyName, StringComparison.InvariantCultureIgnoreCase));`
	`72`	`+ var assemblies = await GetRuntimeAssemblies().ConfigureAwait(false);`
	`73`	`+`
	`74`	`+ var result = assemblies.FirstOrDefault(assembly => assembly.GetName()`
	`75`	`+ .Name.Equals(assemblyName, StringComparison.InvariantCultureIgnoreCase));`
`74`	`76`
`75`	`77`	`if (result != null)`
`76`	`78`	`{`
`@@ -97,7 +99,7 @@ public Assembly FindAssemblyNamed(string name)`
`97`	`99`
`98`	`100`	`if (File.Exists(path))`
`99`	`101`	`{`
`100`		`- return GetAssembly(path);`
	`102`	`+ return await GetAssembly(path);`
`101`	`103`	`}`
`102`	`104`
`103`	`105`	`if (!privateBinPath.Equals(AppDomain.CurrentDomain.BaseDirectory))`
`@@ -106,27 +108,26 @@ public Assembly FindAssemblyNamed(string name)`
`106`	`108`
`107`	`109`	`if (File.Exists(path))`
`108`	`110`	`{`
`109`		`- return GetAssembly(path);`
	`111`	`+ return await GetAssembly(path);`
`110`	`112`	`}`
`111`	`113`	`}`
`112`	`114`	`}`
`113`	`115`
`114`	`116`	`return null;`
`115`	`117`	`}`
`116`	`118`
`117`		`- public IEnumerable<Assembly> GetMatchingAssemblies(Regex regex)`
	`119`	`+ public async Task<IEnumerable<Assembly>> GetMatchingAssemblies(Regex regex)`
`118`	`120`	`{`
`119`	`121`	`Guard.AgainstNull(regex, nameof(regex));`
`120`	`122`
`121`		`- var assemblies =`
`122`		`- new List<Assembly>(GetRuntimeAssemblies().Where(assembly => regex.IsMatch(assembly.FullName)));`
	`123`	`+ var result = (await GetRuntimeAssemblies().ConfigureAwait(false)).Where(assembly => regex.IsMatch(assembly.FullName)).ToList();`
`123`	`124`
`124`	`125`	`foreach (`
`125`	`126`	`var assembly in`
`126`		`- GetMatchingAssemblies(regex, AppDomain.CurrentDomain.BaseDirectory)`
`127`		`- .Where(assembly => assemblies.Find(candidate => candidate.Equals(assembly)) == null))`
	`127`	`+ (await GetMatchingAssemblies(regex, AppDomain.CurrentDomain.BaseDirectory).ConfigureAwait(false))`
	`128`	`+ .Where(assembly => result.Find(candidate => candidate.Equals(assembly)) == null))`
`128`	`129`	`{`
`129`		`- assemblies.Add(assembly);`
	`130`	`+ result.Add(assembly);`
`130`	`131`	`}`
`131`	`132`
`132`	`133`	`var privateBinPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory,`
`@@ -136,25 +137,25 @@ var assembly in`
`136`	`137`	`{`
`137`	`138`	`foreach (`
`138`	`139`	`var assembly in`
`139`		`- GetMatchingAssemblies(regex, privateBinPath)`
`140`		`- .Where(assembly => assemblies.Find(candidate => candidate.Equals(assembly)) == null))`
	`140`	`+ (await GetMatchingAssemblies(regex, privateBinPath).ConfigureAwait(false))`
	`141`	`+ .Where(assembly => result.Find(candidate => candidate.Equals(assembly)) == null))`
`141`	`142`	`{`
`142`		`- assemblies.Add(assembly);`
	`143`	`+ result.Add(assembly);`
`143`	`144`	`}`
`144`	`145`	`}`
`145`	`146`
`146`		`- return assemblies;`
	`147`	`+ return result;`
`147`	`148`	`}`
`148`	`149`
`149`		`- public IEnumerable<Assembly> GetRuntimeAssemblies()`
	`150`	`+ public async Task<IEnumerable<Assembly>> GetRuntimeAssemblies()`
`150`	`151`	`{`
`151`	`152`	`var result = new List<Assembly>();`
`152`	`153`	`var dependencyContext = DependencyContext.Default;`
`153`	`154`
`154`	`155`	`if (dependencyContext != null)`
`155`	`156`	`{`
`156`	`157`	`foreach (var runtimeAssemblyName in dependencyContext.GetRuntimeAssemblyNames(Environment.OSVersion`
`157`		`- .Platform.ToString()))`
	`158`	`+ .Platform.ToString()))`
`158`	`159`	`{`
`159`	`160`	`result.Add(Assembly.Load(runtimeAssemblyName));`
`160`	`161`	`}`
`@@ -168,44 +169,49 @@ public IEnumerable<Assembly> GetRuntimeAssemblies()`
`168`	`169`	`}`
`169`	`170`	`}`
`170`	`171`
`171`		`- return result;`
	`172`	`+ return await Task.FromResult(result);`
`172`	`173`	`}`
`173`	`174`
`174`		`- public IEnumerable<Type> GetTypesAssignableTo(Type type)`
	`175`	`+ public async Task<IEnumerable<Type>> GetTypesAssignableTo(Type type)`
`175`	`176`	`{`
`176`	`177`	`var result = new List<Type>();`
`177`	`178`
`178`		`- foreach (var assembly in this.GetAssemblies())`
	`179`	`+ var assemblies = await this.GetAssemblies().ConfigureAwait(false);`
	`180`	`+`
	`181`	`+ foreach (var assembly in assemblies)`
`179`	`182`	`{`
`180`		`- GetTypesAssignableTo(type, assembly)`
`181`		`- .Where(candidate => result.Find(existing => existing == candidate) == null)`
	`183`	`+ var types = await GetTypesAssignableTo(type, assembly).ConfigureAwait(false);`
	`184`	`+`
	`185`	`+ types.Where(candidate => result.Find(existing => existing == candidate) == null)`
`182`	`186`	`.ToList()`
`183`	`187`	`.ForEach(add => result.Add(add));`
`184`	`188`	`}`
`185`	`189`
`186`	`190`	`return result;`
`187`	`191`	`}`
`188`	`192`
`189`		`- public IEnumerable<Type> GetTypesAssignableTo(Type type, Assembly assembly)`
	`193`	`+ public async Task<IEnumerable<Type>> GetTypesAssignableTo(Type type, Assembly assembly)`
`190`	`194`	`{`
`191`	`195`	`Guard.AgainstNull(type, nameof(type));`
`192`	`196`	`Guard.AgainstNull(assembly, nameof(assembly));`
`193`	`197`
`194`		`- return GetTypes(assembly).Where(candidate =>`
	`198`	`+ var types = await GetTypes(assembly).ConfigureAwait(false);`
	`199`	`+`
	`200`	`+ return types.Where(candidate =>`
`195`	`201`	`candidate.IsAssignableTo(type) && !(candidate.IsInterface && candidate == type)).ToList();`
`196`	`202`	`}`
`197`	`203`
`198`		`- public Type GetType(string typeName)`
	`204`	`+ public async Task<Type> GetType(string typeName)`
`199`	`205`	`{`
`200`		`- return Type.GetType(typeName,`
	`206`	`+ return await Task.FromResult(Type.GetType(typeName,`
`201`	`207`	`assemblyName =>`
`202`	`208`	`{`
`203`	`209`	`Assembly assembly;`
`204`	`210`
`205`	`211`	`try`
`206`	`212`	`{`
`207`	`213`	`assembly = Assembly.LoadFrom(`
`208`		`- Path.Combine(string.IsNullOrEmpty(AppDomain.CurrentDomain.RelativeSearchPath)`
	`214`	`+ Path.Combine(string.IsNullOrEmpty(AppDomain.CurrentDomain.RelativeSearchPath)`
`209`	`215`	`? AppDomain.CurrentDomain.BaseDirectory`
`210`	`216`	`: AppDomain.CurrentDomain.RelativeSearchPath, $"{assemblyName.Name}.dll"));`
`211`	`217`	`}`
`@@ -219,45 +225,43 @@ public Type GetType(string typeName)`
`219`	`225`	`},`
`220`	`226`	`(assembly, typeNameSought, ignore) => assembly == null`
`221`	`227`	`? Type.GetType(typeNameSought, false, ignore)`
`222`		`- : assembly.GetType(typeNameSought, false, ignore));`
	`228`	`+ : assembly.GetType(typeNameSought, false, ignore)));`
`223`	`229`	`}`
`224`	`230`
`225`		`- public IEnumerable<Type> GetTypes(Assembly assembly)`
	`231`	`+ public async Task<IEnumerable<Type>> GetTypes(Assembly assembly)`
`226`	`232`	`{`
`227`	`233`	`Guard.AgainstNull(assembly, nameof(assembly));`
`228`	`234`
`229`		`- Type[] types;`
	`235`	`+ var types = Enumerable.Empty<Type>();`
`230`	`236`
`231`	`237`	`try`
`232`	`238`	`{`
`233`		`- types = assembly.GetTypes();`
	`239`	`+ types = assembly.GetTypes().ToList();`
`234`	`240`	`}`
`235`	`241`	`catch (Exception ex)`
`236`	`242`	`{`
`237`	`243`	`ExceptionRaised.Invoke(this, new ExceptionRaisedEventArgs($"GetTypes({assembly.FullName})", ex));`
`238`		`-`
`239`		`- return new List<Type>();`
`240`	`244`	`}`
`241`	`245`
`242`		`- return types;`
	`246`	`+ return await Task.FromResult(types);`
`243`	`247`	`}`
`244`	`248`
`245`		`- private IEnumerable<Assembly> GetMatchingAssemblies(Regex expression, string folder)`
	`249`	`+ private async Task<IEnumerable<Assembly>> GetMatchingAssemblies(Regex expression, string folder)`
`246`	`250`	`{`
`247`	`251`	`var result = new List<Assembly>();`
`248`	`252`
`249`	`253`	`if (Directory.Exists(folder))`
`250`	`254`	`{`
`251`		`- result.AddRange(`
	`255`	`+ result.AddRange(await Task.WhenAll(`
`252`	`256`	`Directory.GetFiles(folder, "*.exe")`
`253`	`257`	`.Where(file => expression.IsMatch(Path.GetFileNameWithoutExtension(file)))`
`254`	`258`	`.Select(GetAssembly)`
`255`		`- .Where(assembly => assembly != null));`
`256`		`- result.AddRange(`
	`259`	`+ .Where(assembly => assembly != null)));`
	`260`	`+ result.AddRange(await Task.WhenAll(`
`257`	`261`	`Directory.GetFiles(folder, "*.dll")`
`258`	`262`	`.Where(file => expression.IsMatch(Path.GetFileNameWithoutExtension(file)))`
`259`		`- .Select(GetAssembly)`
`260`		`- .Where(assembly => assembly != null));`
	`263`	`+ .Select(assemblyPath => GetAssembly(assemblyPath))`
	`264`	`+ .Where(assembly => assembly != null)));`
`261`	`265`	`}`
`262`	`266`
`263`	`267`	`return result;`