Implicit assembly loading optimization.

dse · dse · commit 8ee0c657dca1 · 2017-08-23T16:24:26.000+04:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -8,6 +8,7 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 ## [unreleased][]
 
 ### Added
+-   Optimized implicit assembly loading on module import, PythonEngine.ImplicitAssemblyLoading event added.
 -   Added support for embedding python into dotnet core 2.0 (NetStandard 2.0)
 -   Added new build system (pythonnet.15.sln) based on dotnetcore-sdk/xplat(crossplatform msbuild).
     Currently there two side-by-side build systems that produces the same output (net40) from the same sources.
diff --git a/src/runtime/assemblymanager.cs b/src/runtime/assemblymanager.cs
@@ -196,6 +196,14 @@ public static Assembly LoadAssembly(string name)
             Assembly assembly = null;
             try
             {
+                var importEvent = new ImplicitAssemblyLoadingEventArgs(name);
+                if (importEvent.SkipAssemblyLoad)
+                {
+                    return null;
+                }
+
+                PythonEngine.RaiseAssemblyAsModuleImportingEvent(importEvent);
+
                 assembly = Assembly.Load(name);
             }
             catch (Exception)
@@ -419,12 +427,15 @@ public static List<string> GetNames(string nsname)
             {
                 foreach (Assembly a in namespaces[nsname].Keys)
                 {
-                    Type[] types = a.GetTypes();
+                    Type[] types = a.IsDynamic ? a.GetTypes(): a.GetExportedTypes();
                     foreach (Type t in types)
                     {
                         if ((t.Namespace ?? "") == nsname)
                         {
-                            names.Add(t.Name);
+                            if (!t.IsNested)
+                            {
+                                names.Add(t.Name);
+                            }
                         }
                     }
                 }
diff --git a/src/runtime/pythonengine.cs b/src/runtime/pythonengine.cs
@@ -1,4 +1,4 @@
-﻿using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -130,6 +130,11 @@ public static string Compiler
             get { return Marshal.PtrToStringAnsi(Runtime.Py_GetCompiler()); }
         }
 
+        /// <summary>
+        /// Fires when python engines importing module and probably tries to load an assembly.
+        /// </summary>
+        public static event EventHandler<ImplicitAssemblyLoadingEventArgs> ImplicitAssemblyLoading;
+
         public static int RunSimpleString(string code)
         {
             return Runtime.PyRun_SimpleString(code);
@@ -520,6 +525,29 @@ internal static PyObject RunString(string code, IntPtr? globals, IntPtr? locals,
                 }
             }
         }
+
+        internal static void RaiseAssemblyAsModuleImportingEvent(ImplicitAssemblyLoadingEventArgs e)
+        {
+            ImplicitAssemblyLoading?.Invoke(null, e);
+        }
+    }
+
+    public class ImplicitAssemblyLoadingEventArgs: EventArgs
+    {
+        public ImplicitAssemblyLoadingEventArgs(string moduleName)
+        {
+            ModuleName = moduleName;
+        }
+
+        /// <summary>
+        /// The name of the module to import that is probably assembly name.
+        /// </summary>
+        public string ModuleName { get; }
+
+        /// <summary>
+        /// Set it to true, if you know that <see cref="ModuleName"/> is not an assembly to import.
+        /// </summary>
+        public bool SkipAssemblyLoad { get; set; }
     }
 
     public enum RunFlagType

Original file line number	Diff line number	Diff line change
`@@ -196,6 +196,14 @@ public static Assembly LoadAssembly(string name)`
`196`	`196`	`Assembly assembly = null;`
`197`	`197`	`try`
`198`	`198`	`{`
	`199`	`+ var importEvent = new ImplicitAssemblyLoadingEventArgs(name);`
	`200`	`+ if (importEvent.SkipAssemblyLoad)`
	`201`	`+ {`
	`202`	`+ return null;`
	`203`	`+ }`
	`204`	`+`
	`205`	`+ PythonEngine.RaiseAssemblyAsModuleImportingEvent(importEvent);`
	`206`	`+`
`199`	`207`	`assembly = Assembly.Load(name);`
`200`	`208`	`}`
`201`	`209`	`catch (Exception)`
`@@ -419,12 +427,15 @@ public static List<string> GetNames(string nsname)`
`419`	`427`	`{`
`420`	`428`	`foreach (Assembly a in namespaces[nsname].Keys)`
`421`	`429`	`{`
`422`		`- Type[] types = a.GetTypes();`
	`430`	`+ Type[] types = a.IsDynamic ? a.GetTypes(): a.GetExportedTypes();`
`423`	`431`	`foreach (Type t in types)`
`424`	`432`	`{`
`425`	`433`	`if ((t.Namespace ?? "") == nsname)`
`426`	`434`	`{`
`427`		`- names.Add(t.Name);`
	`435`	`+ if (!t.IsNested)`
	`436`	`+ {`
	`437`	`+ names.Add(t.Name);`
	`438`	`+ }`
`428`	`439`	`}`
`429`	`440`	`}`
`430`	`441`	`}`