@@ -12,6 +12,7 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
     Usage: Python.EmbeddingTest.exe --loop --where="cat != Unstable"
 -   Improved performance. String marshaling between python and clr now cached. 
     Cache reduces GC pressure and saves from extensive memory copying.
+-   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.
 
@@ -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);
+                            }
                         }
                     }
                 }
 
@@ -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);
@@ -554,6 +559,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	}