Types.InAssembly - add option to load referenced assemblies

Author: NeVeSpl

samples/NetArchTest.SampleTests/NetArchTest.SampleTests.csproj

@@ -18,6 +18,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\sources\NetArchTest\NetArchTest.csproj" />
+    <ProjectReference Include="..\SampleApp.API\SampleApp.API.csproj" />
     <ProjectReference Include="..\SampleApp.ModuleAlpha\SampleApp.ModuleAlpha.csproj" />
     <ProjectReference Include="..\SampleApp.ModuleOmega\SampleApp.ModuleOmega.csproj" />
   </ItemGroup>

samples/SampleApp.API/SampleApp.API.csproj

@@ -7,4 +7,9 @@
     <InvariantGlobalization>true</InvariantGlobalization>
   </PropertyGroup>
 
+  <ItemGroup>
+    <ProjectReference Include="..\SampleApp.ModuleAlpha\SampleApp.ModuleAlpha.csproj" />
+    <ProjectReference Include="..\SampleApp.ModuleOmega\SampleApp.ModuleOmega.csproj" />
+  </ItemGroup>
+
 </Project>

sources/NetArchTest/Assemblies/AssemblySpec.cs

@@ -10,6 +10,10 @@ internal sealed class AssemblySpec
     {
         private AssemblyDefinition assemblyDefinition;
         private IReadOnlyList<TypeDefinition> typeDefinitions;
+        private List<AssemblySpec> referenced = new List<AssemblySpec>();
+
+        public string FullName => assemblyDefinition.FullName;
+
 
 
         public AssemblySpec(AssemblyDefinition assemblyDefinition, IEnumerable<TypeDefinition> typeDefinitions)
@@ -18,13 +22,18 @@ public AssemblySpec(AssemblyDefinition assemblyDefinition, IEnumerable<TypeDefin
             this.typeDefinitions = typeDefinitions.ToArray();
         }
 
+        public void AddRef(AssemblySpec assemblySpec)
+        {
+            referenced.Add(assemblySpec);
+        }
 
         public IEnumerable<TypeSpec> GetTypes() 
         {
             return typeDefinitions.Select(x => new TypeSpec(x));
         }
 
 
+
         public IAssembly CreateWrapper()
         {
             return new AssemblyContainer(assemblyDefinition);

sources/NetArchTest/Assemblies/DataLoader.cs

@@ -17,7 +17,7 @@ internal static class DataLoader
             "netstandard", 
             "NuGet", 
             "Newtonsoft",
-            "Xunit", 
+            "xunit", 
             "Internal.Microsoft",
             "Mono.Cecil",
             "NetArchTest.Assemblies",
@@ -38,36 +38,65 @@ public static LoadedData LoadFromCurrentDomain()
 
             return LoadFromAssemblies(selectedAssemblies);
         }
-        public static LoadedData LoadFromAssemblies(IEnumerable<Assembly> assemblies, IEnumerable<string> searchDirectories = null)
+        public static LoadedData LoadFromAssemblies(IEnumerable<Assembly> assemblies, IEnumerable<string> searchDirectories = null, bool loadReferencedAssemblies = false)
         {
             var files = assemblies.Select(x => x.Location);
 
-            return LoadFromFiles(files, searchDirectories);
+            return LoadFromFiles(files, searchDirectories, loadReferencedAssemblies);
         }
-        public static LoadedData LoadFromFiles(IEnumerable<string> fileNames, IEnumerable<string> searchDirectories = null)
+        public static LoadedData LoadFromFiles(IEnumerable<string> fileNames, IEnumerable<string> searchDirectories = null, bool loadReferencedAssemblies = false)
         {
-            var assemblies = Load(fileNames, searchDirectories);
+            var assemblies = Load(fileNames, searchDirectories, loadReferencedAssemblies);
 
             return new LoadedData(assemblies);
         }
 
 
-        private static IEnumerable<AssemblySpec> Load(IEnumerable<string> fileNames, IEnumerable<string> searchDirectories = null)
+        private static IEnumerable<AssemblySpec> Load(IEnumerable<string> fileNames, IEnumerable<string> searchDirectories, bool loadReferencedAssemblies)
         {
             var readerParameters = CreateReaderParameters(searchDirectories);
+            var definitions = new Dictionary<string, AssemblySpec>();
 
             foreach (var fileName in fileNames)
             {
                 var assemblyDefinition = ReadAssemblyDefinition(fileName, readerParameters);
-                if (assemblyDefinition == null) continue;
+                ProcessAssemblyDefinition(null, assemblyDefinition);
+            }
 
-                if (exclusionTree.GetAllMatchingNames(assemblyDefinition.Name.Name).Any() == true) continue;
+            void ProcessAssemblyDefinition(AssemblySpec parent, AssemblyDefinition assemblyDefinition)
+            {
+                if (assemblyDefinition == null) return;
+                if (exclusionTree.GetAllMatchingNames(assemblyDefinition.Name.Name).Any() == true) return;
+                if (definitions.TryGetValue(assemblyDefinition.FullName, out var existingSpec))
+                {
+                    parent?.AddRef(existingSpec);
+                    return;
+                }
 
                 var typeDefinitions = ReadTypes(assemblyDefinition);
+                var spec = new AssemblySpec(assemblyDefinition, typeDefinitions);
+
+                definitions.Add(assemblyDefinition.FullName, spec);
+                parent?.AddRef(spec);
 
-                yield return new AssemblySpec(assemblyDefinition, typeDefinitions);
+                if (loadReferencedAssemblies == false) return;
+
+                foreach (var module in assemblyDefinition.Modules)
+                {
+                    if (module.HasAssemblyReferences)
+                    {
+                        foreach (var reference in module.AssemblyReferences)
+                        {
+                            var refAssembly = module.AssemblyResolver.Resolve(reference);
+                            ProcessAssemblyDefinition(spec, refAssembly);
+                        }
+                    }
+                }
             }
+
+            return definitions.Values;
         }
+       
         private static ReaderParameters CreateReaderParameters(IEnumerable<string> searchDirectories, bool readSymbols = true)
         {
             DefaultAssemblyResolver assemblyResolver = null;

sources/NetArchTest/Types.cs

@@ -41,9 +41,9 @@ public static Types InCurrentDomain()
         /// <param name="assembly">The assembly to base the list on.</param>
         /// <param name="searchDirectories">An optional list of search directories to allow resolution of referenced assemblies.</param>
         /// <returns>A list of types that can have predicates and conditions applied to it.</returns>
-        public static Types InAssembly(Assembly assembly, IEnumerable<string> searchDirectories = null)
+        public static Types InAssembly(Assembly assembly, IEnumerable<string> searchDirectories = null, bool loadReferencedAssemblies = false)
         {
-            return Types.InAssemblies(new List<Assembly> { assembly }, searchDirectories);
+            return Types.InAssemblies(new List<Assembly> { assembly }, searchDirectories, loadReferencedAssemblies);
         }
 
         /// <summary>
@@ -52,9 +52,9 @@ public static Types InAssembly(Assembly assembly, IEnumerable<string> searchDire
         /// <param name="assemblies">The assemblies to base the list on.</param>
         /// <param name="searchDirectories">An optional list of search directories to allow resolution of referenced assemblies.</param>
         /// <returns>A list of types that can have predicates and conditions applied to it.</returns>
-        public static Types InAssemblies(IEnumerable<Assembly> assemblies, IEnumerable<string> searchDirectories = null)
+        public static Types InAssemblies(IEnumerable<Assembly> assemblies, IEnumerable<string> searchDirectories = null, bool loadReferencedAssemblies = false)
         {
-            return new Types(DataLoader.LoadFromAssemblies(assemblies, searchDirectories));
+            return new Types(DataLoader.LoadFromAssemblies(assemblies, searchDirectories, loadReferencedAssemblies));
         }
 
         /// <summary>

tests/NetArchTest.Rules.UnitTests/TypesTests.cs

@@ -1,6 +1,7 @@
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using NetArchTest.CrossAssemblyTest.A;
 using NetArchTest.Rules;
 using Xunit;
 
@@ -98,5 +99,31 @@ public void FromFile_BadImage_CaughtAndEmptyListReturned()
             // Assert
             Assert.Empty(result);
         }
+
+
+        [Fact(DisplayName = "InAssembly can load types from referenced assemblies")]
+        public void InAssembly_LoadReferencedAssemblies_True()
+        {
+            // Act
+            var result = Types.InAssembly(typeof(TypesTests).Assembly, loadReferencedAssemblies: true)
+                              .GetTypes()
+                              .Select(x => x.ReflectionType)
+                              .ToArray();
+
+            // Assert
+            Assert.Contains(typeof(BaseClassFromA), result);
+        }
+        [Fact(DisplayName = "InAssembly can not load types from referenced assemblies")]
+        public void InAssembly_LoadReferencedAssemblies_False()
+        {
+            // Act
+            var result = Types.InAssembly(typeof(TypesTests).Assembly, loadReferencedAssemblies: false)
+                              .GetTypes()
+                              .Select(x => x.ReflectionType)
+                              .ToArray();
+
+            // Assert
+            Assert.DoesNotContain(typeof(BaseClassFromA), result);
+        }
     }
 }