Merge

dse · dse · commit cefa377a1eb1 · 2017-11-17T02:26:49.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.
 -   Improved performance. String marshaling between python and clr now cached. 
     Cache reduces GC pressure and saves from extensive memory copying.
 -   Added tool for debugging floating bugs. Stable tests are executed in the loop. ~100 cycles is enough to pop up any bugs.
diff --git a/src/runtime/assemblymanager.cs b/src/runtime/assemblymanager.cs
@@ -194,7 +194,17 @@ public static Assembly LoadAssembly(string name)
             Assembly assembly = null;
             try
             {
-                assembly = Assembly.Load(name);
+                var importEvent = new ImplicitAssemblyLoadingEventArgs(name);
+                if (importEvent.SkipAssemblyLoad)
+                {
+                    return null;
+                }
+
+                PythonEngine.RaiseAssemblyAsModuleImportingEvent(importEvent);
+                if (!importEvent.SkipAssemblyLoad)
+                {
+                    assembly = Assembly.Load(name);
+                }
             }
             catch (Exception)
             {
@@ -341,8 +351,17 @@ internal static void ScanAssembly(Assembly assembly)
             // A couple of things we want to do here: first, we want to
             // gather a list of all of the namespaces contributed to by
             // the assembly.
+            Type[] types = new Type[0];
+            try
+            {
+                types = assembly.IsDynamic ? assembly.GetTypes():assembly.GetExportedTypes();
+            }
+            catch(TypeLoadException)
+            {
+                // Do nothing.
+                // This problem usually occurs when transitive dependencies have references to older packages than main application.
+            }
 
-            Type[] types = assembly.GetTypes();
             foreach (Type t in types)
             {
                 string ns = t.Namespace ?? "";
@@ -417,12 +436,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
@@ -139,6 +139,11 @@ public static string Compiler
 
         internal static PyReferenceDecrementer CurrentRefDecrementer { get; private set; }
 
+        /// <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);
@@ -560,6 +565,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
`@@ -194,7 +194,17 @@ public static Assembly LoadAssembly(string name)`
`194`	`194`	`Assembly assembly = null;`
`195`	`195`	`try`
`196`	`196`	`{`
`197`		`- assembly = Assembly.Load(name);`
	`197`	`+ var importEvent = new ImplicitAssemblyLoadingEventArgs(name);`
	`198`	`+ if (importEvent.SkipAssemblyLoad)`
	`199`	`+ {`
	`200`	`+ return null;`
	`201`	`+ }`
	`202`	`+`
	`203`	`+ PythonEngine.RaiseAssemblyAsModuleImportingEvent(importEvent);`
	`204`	`+ if (!importEvent.SkipAssemblyLoad)`
	`205`	`+ {`
	`206`	`+ assembly = Assembly.Load(name);`
	`207`	`+ }`
`198`	`208`	`}`
`199`	`209`	`catch (Exception)`
`200`	`210`	`{`
`@@ -341,8 +351,17 @@ internal static void ScanAssembly(Assembly assembly)`
`341`	`351`	`// A couple of things we want to do here: first, we want to`
`342`	`352`	`// gather a list of all of the namespaces contributed to by`
`343`	`353`	`// the assembly.`
	`354`	`+ Type[] types = new Type[0];`
	`355`	`+ try`
	`356`	`+ {`
	`357`	`+ types = assembly.IsDynamic ? assembly.GetTypes():assembly.GetExportedTypes();`
	`358`	`+ }`
	`359`	`+ catch(TypeLoadException)`
	`360`	`+ {`
	`361`	`+ // Do nothing.`
	`362`	`+ // This problem usually occurs when transitive dependencies have references to older packages than main application.`
	`363`	`+ }`
`344`	`364`
`345`		`- Type[] types = assembly.GetTypes();`
`346`	`365`	`foreach (Type t in types)`
`347`	`366`	`{`
`348`	`367`	`string ns = t.Namespace ?? "";`
`@@ -417,12 +436,15 @@ public static List<string> GetNames(string nsname)`
`417`	`436`	`{`
`418`	`437`	`foreach (Assembly a in namespaces[nsname].Keys)`
`419`	`438`	`{`
`420`		`- Type[] types = a.GetTypes();`
	`439`	`+ Type[] types = a.IsDynamic ? a.GetTypes(): a.GetExportedTypes();`
`421`	`440`	`foreach (Type t in types)`
`422`	`441`	`{`
`423`	`442`	`if ((t.Namespace ?? "") == nsname)`
`424`	`443`	`{`
`425`		`- names.Add(t.Name);`
	`444`	`+ if (!t.IsNested)`
	`445`	`+ {`
	`446`	`+ names.Add(t.Name);`
	`447`	`+ }`
`426`	`448`	`}`
`427`	`449`	`}`
`428`	`450`	`}`