Allow loading assemblies without an assembly location

src/Microsoft.Performance.SDK.Runtime/AssemblyTypeReference.cs

@@ -47,7 +47,7 @@ protected internal AssemblyTypeReference(Type type)
 
             this.type = type;
 
-            if (!this.Type.Assembly.IsDynamic)
+            if (!this.Type.Assembly.IsDynamic && !string.IsNullOrWhiteSpace(this.Type.Assembly.Location))
             {
                 this.assemblyPath = this.Type.Assembly.Location;
                 this.version = FileVersionInfo.GetVersionInfo(this.AssemblyPath).FileVersion;

src/Microsoft.Performance.SDK.Runtime/Discovery/AssemblyExtensionDiscovery.cs

@@ -359,7 +359,7 @@ public bool ProcessAssemblies(
             return allLoaded;
         }
 
-        private bool ProcessAssembly(
+        public bool ProcessAssembly(
             Assembly assembly,
             out ErrorInfo error)
         {

src/Microsoft.Performance.Toolkit.Engine/PluginSet.cs

@@ -6,6 +6,7 @@
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Reflection;
 using Microsoft.Performance.SDK;
 using Microsoft.Performance.SDK.Extensibility;
 using Microsoft.Performance.SDK.Runtime;
@@ -258,6 +259,49 @@ public static PluginSet Load(
         public static PluginSet Load(
             IEnumerable<string> extensionDirectories,
             IAssemblyLoader assemblyLoader)
+        {
+            return Load(extensionDirectories, assemblyLoader, null);
+        }
+        /// <summary>
+        ///     Creates a new <see cref="PluginSet"/>, loading all plugins found
+        ///     in the given directories, using the given loading function, and
+        ///     any extra direct assemblies specified
+        /// </summary>
+        /// <param name="extensionDirectories">
+        ///     The directories to search for plugins.
+        /// </param>
+        /// <param name="assemblyLoader">
+        ///     The loader to use to load plugin assemblies. This parameter may be
+        ///     <c>null</c>. If this parameter is <c>null</c>, then the default
+        ///     loader will be used.
+        ///     <remarks>
+        ///         The default loader provides no isolation.
+        ///     </remarks>
+        /// </param>
+        /// <param name="extraAssemblies">
+        ///     A list of extra assemblies to attemt to directly load plugins from.
+        ///     This parameter may be <c>null</c> or <c>empty</c>.
+        /// </param>
+        /// <returns>
+        ///     A new instance of the <see cref="PluginSet"/> class containing all
+        ///     of the successfully discovered plugins. The returned instance will
+        ///     also contain a collection of non-fatal errors that occurred when
+        ///     creating this data set (e.g. a plugin failed to load.)
+        /// </returns>
+        /// <exception cref="System.ArgumentNullException">
+        ///     <paramref name="extensionDirectories"/> is <c>null</c>.
+        /// </exception>
+        /// <exception cref="System.ArgumentException">
+        ///     <paramref name="extensionDirectories"/> is empty.
+        /// </exception>
+        /// <exception cref="InvalidExtensionDirectoryException">
+        ///     One or more directory paths in <paramref name="extensionDirectories"/>
+        ///     is invalid or does not exist.
+        /// </exception>
+        public static PluginSet Load(
+            IEnumerable<string> extensionDirectories,
+            IAssemblyLoader assemblyLoader,
+            IEnumerable<Assembly> extraAssemblies)
         {
             Guard.NotNull(extensionDirectories, nameof(extensionDirectories));
             Guard.Any(extensionDirectories, nameof(extensionDirectories));
@@ -307,13 +351,31 @@ public static PluginSet Load(
 
                 var reflector = new DataExtensionReflector(assemblyDiscovery, repo);
 
+                var creationErrors = new List<ErrorInfo>();
+
                 assemblyDiscovery.ProcessAssemblies(extensionDirectoriesFullPaths, out var discoveryError);
 
-                repo.FinalizeDataExtensions();
+                if (discoveryError != null && discoveryError != ErrorInfo.None)
+                {
+                    creationErrors.Add(discoveryError);
+                }
 
-                var creationErrors = discoveryError != null && discoveryError != ErrorInfo.None
-                    ? new[] { discoveryError, }
-                    : Array.Empty<ErrorInfo>();
+                if (extraAssemblies != null)
+                {
+                    foreach (var assembly in extraAssemblies)
+                    {
+                        if (assembly != null)
+                        {
+                            assemblyDiscovery.ProcessAssembly(assembly, out discoveryError);
+                            if (discoveryError != null && discoveryError != ErrorInfo.None)
+                            {
+                                creationErrors.Add(discoveryError);
+                            }
+                        }
+                    }
+                }
+
+                repo.FinalizeDataExtensions();
 
                 extensionRoot = new ExtensionRoot(catalog, repo);