Merge pull request #153 from qba97/master

#132 - fix missing namespaces issue while processing model DLL
mpostol · Feb 2, 2019 · 7a67a63 · 7a67a63
2 parents e032d9a + 250f60f
commit 7a67a63
Show file tree

Hide file tree

Showing 3 changed files with 26 additions and 2 deletions.
diff --git a/AdaptiveProgramming/Reflection/Model/AssemblyMetadata.cs b/AdaptiveProgramming/Reflection/Model/AssemblyMetadata.cs
@@ -13,7 +13,6 @@ internal AssemblyMetadata(Assembly assembly)
     {
       m_Name = assembly.ManifestModule.Name;
       m_Namespaces = from Type _type in assembly.GetTypes()
-                     where _type.GetVisible()
                      group _type by _type.GetNamespace() into _group
                      orderby _group.Key
                      select new NamespaceMetadata(_group.Key, _group);

diff --git a/AdaptiveProgramming/Reflection/Model/TypeMetadata.cs b/AdaptiveProgramming/Reflection/Model/TypeMetadata.cs
@@ -12,6 +12,10 @@ internal class TypeMetadata
     #region constructors
     internal TypeMetadata(Type type)
     {
+      if (!storedTypes.ContainsKey(type.Name))
+      {
+        storedTypes.Add(type.Name, this);
+      }
       m_typeName = type.Name;
       m_DeclaringType = EmitDeclaringType(type.DeclaringType);
       m_Constructors = MethodMetadata.EmitMethods(type.GetConstructors());
@@ -46,6 +50,7 @@ internal static IEnumerable<TypeMetadata> EmitGenericArguments(IEnumerable<Type>
     #endregion
 
     #region private
+    private static Dictionary<string, TypeMetadata> storedTypes = new Dictionary<string, TypeMetadata>();
     //vars
     internal string m_typeName;
     internal string m_NamespaceName;
@@ -75,16 +80,19 @@ private TypeMetadata EmitDeclaringType(Type declaringType)
     {
       if (declaringType == null)
         return null;
+      AddToStoredTypes(declaringType);
       return EmitReference(declaringType);
     }
     private IEnumerable<TypeMetadata> EmitNestedTypes(IEnumerable<Type> nestedTypes)
     {
+      AddToStoredTypes(nestedTypes);
       return from _type in nestedTypes
              where _type.GetVisible()
              select new TypeMetadata(_type);
     }
     private IEnumerable<TypeMetadata> EmitImplements(IEnumerable<Type> interfaces)
     {
+      AddToStoredTypes(interfaces);
       return from currentInterface in interfaces
              select EmitReference(currentInterface);
     }
@@ -120,8 +128,26 @@ private static TypeMetadata EmitExtends(Type baseType)
     {
       if (baseType == null || baseType == typeof(Object) || baseType == typeof(ValueType) || baseType == typeof(Enum))
         return null;
+      AddToStoredTypes(baseType);
       return EmitReference(baseType);
     }
+
+    private static void AddToStoredTypes(Type type)
+    {
+      if (!storedTypes.ContainsKey(type.Name))
+      {
+        // TypeMetadata object is added to dictionary when invoking its constructor
+        new TypeMetadata(type);
+      }
+    }
+
+    private static void AddToStoredTypes(IEnumerable<Type> types)
+    {
+      foreach (Type type in types)
+      {
+        AddToStoredTypes(type);
+      }
+    }
     #endregion
 
   }

diff --git a/AdaptiveProgramming/ReflectionUnitTest/ReflectorUnitTest.cs b/AdaptiveProgramming/ReflectionUnitTest/ReflectorUnitTest.cs
@@ -27,7 +27,6 @@ public void ReflectorConstructorTest()
       Assert.IsTrue(_fileInfo.Exists);
       Assert.IsNotNull(ReflectorTestClass.Reflector);
       Assert.IsNotNull(ReflectorTestClass.Reflector.MyNamespace);
-      Assert.Inconclusive("Nor all types are processed - test fails.");
       Assert.AreEqual<int>(4, ReflectorTestClass.Reflector.Namespaces.Count);
     }
     [TestMethod]