@@ -26,6 +26,7 @@
 -   Dmitriy Se ([@dmitriyse](https://github.com/dmitriyse))
 -   He-chien Tsai ([@t3476](https://github.com/t3476))
 -   Ivan Cronyn ([@cronan](https://github.com/cronan))
+-   Jan Krivanek ([@jakrivan](https://github.com/jakrivan))
 -   Jeff Reback ([@jreback](https://github.com/jreback))
 -   Joe Frayne ([@jfrayne](https://github.com/jfrayne))
 -   John Burnett ([@johnburnett](https://github.com/johnburnett))
 
@@ -20,6 +20,7 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 -   Implemented GetDynamicMemberNames() for PyObject to allow dynamic object members to be visible in the debugger ([#443][i443])([#690][p690])
 -   Incorporated reference-style links to issues and pull requests in the CHANGELOG ([#608][i608])
 -   Added PyObject finalizer support, Python objects referred by C# can be auto collect now ([#692][p692]).
+-   Added detailed comments about aproaches and dangers to handle multi-app-domains ([#625][p625])
 
 ### Changed
 -   PythonException included C# call stack
@@ -685,4 +686,5 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 [p225]: https://github.com/pythonnet/pythonnet/pull/225
 [p78]: https://github.com/pythonnet/pythonnet/pull/78
 [p163]: https://github.com/pythonnet/pythonnet/pull/163
+[p625]: https://github.com/pythonnet/pythonnet/pull/625
 [i131]: https://github.com/pythonnet/pythonnet/issues/131
@@ -17,7 +17,15 @@ internal class AssemblyManager
     {
         // modified from event handlers below, potentially triggered from different .NET threads
         // therefore this should be a ConcurrentDictionary
+        //
+        // WARNING: Dangerous if cross-app domain usage is ever supported
+        //    Reusing the dictionary with assemblies accross multiple initializations is problematic. 
+        //    Loading happens from CurrentDomain (see line 53). And if the first call is from AppDomain that is later unloaded, 
+        //    than it can end up referring to assemblies that are already unloaded (default behavior after unload appDomain - 
+        //     unless LoaderOptimization.MultiDomain is used);
+        //    So for multidomain support it is better to have the dict. recreated for each app-domain initialization
         private static ConcurrentDictionary<string, ConcurrentDictionary<Assembly, string>> namespaces;
+
         //private static Dictionary<string, Dictionary<string, string>> generics;
         private static AssemblyLoadEventHandler lhandler;
         private static ResolveEventHandler rhandler;
 
@@ -237,6 +237,11 @@ public static IntPtr __import__(IntPtr self, IntPtr args, IntPtr kw)
                 if (res != IntPtr.Zero)
                 {
                     // There was no error.
+                    if (fromlist && IsLoadAll(fromList))
+                    {
+                        var mod = ManagedType.GetManagedObject(res) as ModuleObject;
+                        mod?.LoadNames();
+                    }
                     return res;
                 }
                 // There was an error
@@ -290,6 +295,11 @@ public static IntPtr __import__(IntPtr self, IntPtr args, IntPtr kw)
             {
                 if (fromlist)
                 {
+                    if (IsLoadAll(fromList))
+                    {
+                        var mod = ManagedType.GetManagedObject(module) as ModuleObject;
+                        mod?.LoadNames();
+                    }
                     Runtime.XIncref(module);
                     return module;
                 }
@@ -345,20 +355,33 @@ public static IntPtr __import__(IntPtr self, IntPtr args, IntPtr kw)
                 }
             }
 
-            ModuleObject mod = fromlist ? tail : head;
-
-            if (fromlist && Runtime.PySequence_Size(fromList) == 1)
             {
-                IntPtr fp = Runtime.PySequence_GetItem(fromList, 0);
-                if (!CLRModule.preload && Runtime.GetManagedString(fp) == "*")
+                var mod = fromlist ? tail : head;
+
+                if (fromlist && IsLoadAll(fromList))
                 {
                     mod.LoadNames();
                 }
-                Runtime.XDecref(fp);
+
+                Runtime.XIncref(mod.pyHandle);
+                return mod.pyHandle;
             }
+        }
 
-            Runtime.XIncref(mod.pyHandle);
-            return mod.pyHandle;
+        private static bool IsLoadAll(IntPtr fromList)
+        {
+            if (CLRModule.preload)
+            {
+                return false;
+            }
+            if (Runtime.PySequence_Size(fromList) != 1)
+            {
+                return false;
+            }
+            IntPtr fp = Runtime.PySequence_GetItem(fromList, 0);
+            bool res = Runtime.GetManagedString(fp) == "*";
+            Runtime.XDecref(fp);
+            return res;
         }
     }
 }
@@ -190,10 +190,17 @@ public void LoadNames()
             foreach (string name in AssemblyManager.GetNames(_namespace))
             {
                 cache.TryGetValue(name, out m);
-                if (m == null)
+                if (m != null)
                 {
-                    ManagedType attr = GetAttribute(name, true);
+                    continue;
                 }
+                IntPtr attr = Runtime.PyDict_GetItemString(dict, name);
+                // If __dict__ has already set a custom property, skip it.
+                if (attr != IntPtr.Zero)
+                {
+                    continue;
+                }
+                GetAttribute(name, true);
             }
         }
 
 
@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+import sys
+try:
+    del sys.modules["System.IO"]
+except KeyError:
+    pass
+
+assert "FileStream" not in globals()
+import System.IO
+from System.IO import *
+
+assert "FileStream" in globals()
@@ -3,11 +3,20 @@
 """Test the import statement."""
 
 import pytest
-
+import sys
 
 def test_relative_missing_import():
     """Test that a relative missing import doesn't crash.
     Some modules use this to check if a package is installed.
     Relative import in the site-packages folder"""
     with pytest.raises(ImportError):
         from . import _missing_import
+
+
+def test_import_all_on_second_time():
+    """Test import all attributes after a normal import without '*'.
+    Due to import * only allowed at module level, the test body splited
+    to a module file."""
+    from . import importtest
+    del sys.modules[importtest.__name__]
+
Original file line number	Diff line number	Diff line change
@@ -237,6 +237,11 @@ public static IntPtr __import__(IntPtr self, IntPtr args, IntPtr kw)
237	237	if (res != IntPtr.Zero)
238	238	{
239	239	// There was no error.
	240	+ if (fromlist && IsLoadAll(fromList))
	241	+ {
	242	+ var mod = ManagedType.GetManagedObject(res) as ModuleObject;
	243	+ mod?.LoadNames();
	244	+ }
240	245	return res;
241	246	}
242	247	// There was an error
@@ -290,6 +295,11 @@ public static IntPtr __import__(IntPtr self, IntPtr args, IntPtr kw)
290	295	{
291	296	if (fromlist)
292	297	{
	298	+ if (IsLoadAll(fromList))
	299	+ {
	300	+ var mod = ManagedType.GetManagedObject(module) as ModuleObject;
	301	+ mod?.LoadNames();
	302	+ }
293	303	Runtime.XIncref(module);
294	304	return module;
295	305	}
@@ -345,20 +355,33 @@ public static IntPtr __import__(IntPtr self, IntPtr args, IntPtr kw)
345	355	}
346	356	}
347	357
348		- ModuleObject mod = fromlist ? tail : head;
349		-
350		- if (fromlist && Runtime.PySequence_Size(fromList) == 1)
351	358	{
352		- IntPtr fp = Runtime.PySequence_GetItem(fromList, 0);
353		- if (!CLRModule.preload && Runtime.GetManagedString(fp) == "*")
	359	+ var mod = fromlist ? tail : head;
	360	+
	361	+ if (fromlist && IsLoadAll(fromList))
354	362	{
355	363	mod.LoadNames();
356	364	}
357		- Runtime.XDecref(fp);
	365	+
	366	+ Runtime.XIncref(mod.pyHandle);
	367	+ return mod.pyHandle;
358	368	}
	369	+ }
359	370
360		- Runtime.XIncref(mod.pyHandle);
361		- return mod.pyHandle;
	371	+ private static bool IsLoadAll(IntPtr fromList)
	372	+ {
	373	+ if (CLRModule.preload)
	374	+ {
	375	+ return false;
	376	+ }
	377	+ if (Runtime.PySequence_Size(fromList) != 1)
	378	+ {
	379	+ return false;
	380	+ }
	381	+ IntPtr fp = Runtime.PySequence_GetItem(fromList, 0);
	382	+ bool res = Runtime.GetManagedString(fp) == "*";
	383	+ Runtime.XDecref(fp);
	384	+ return res;
362	385	}
363	386	}
364	387	}
Original file line number	Diff line number	Diff line change
@@ -190,10 +190,17 @@ public void LoadNames()
190	190	foreach (string name in AssemblyManager.GetNames(_namespace))
191	191	{
192	192	cache.TryGetValue(name, out m);
193		- if (m == null)
	193	+ if (m != null)
194	194	{
195		- ManagedType attr = GetAttribute(name, true);
	195	+ continue;
196	196	}
	197	+ IntPtr attr = Runtime.PyDict_GetItemString(dict, name);
	198	+ // If __dict__ has already set a custom property, skip it.
	199	+ if (attr != IntPtr.Zero)
	200	+ {
	201	+ continue;
	202	+ }
	203	+ GetAttribute(name, true);
197	204	}
198	205	}
199	206