various refactorings:

internalised/privatised implementation details
expanded parameter types
made fields readonly
converted simple delegates to expressions
converted conditionals to LINQ calls
converted for..each list add to AddRange()
removed redundant code
whitespace fixes
added R# settings

Author: adamralph

ScriptCs.sln.DotSettings

@@ -0,0 +1,2 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateInstanceFields/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="_" Suffix="" Style="aaBb" /&gt;</s:String></wpf:ResourceDictionary>

src/ScriptCs.Contracts/IAppDomainAssemblyResolver.cs

@@ -4,7 +4,6 @@ namespace ScriptCs.Contracts
 {
     public interface IAppDomainAssemblyResolver
     {
-        void AddAssemblyPaths(IEnumerable<string> assemblyPaths);
         void Initialize();
     }
 }

src/ScriptCs.Core/AppDomainAssemblyResolver.cs

@@ -13,7 +13,7 @@ public class AppDomainAssemblyResolver : IAppDomainAssemblyResolver
         private readonly IFileSystem _fileSystem;
         private readonly IAssemblyResolver _resolver;
         private readonly IAssemblyUtility _assemblyUtility;
-        private IDictionary<string, AssemblyInfo> _assemblyInfoMap;
+        private readonly IDictionary<string, AssemblyInfo> _assemblyInfoMap;
 
         public AppDomainAssemblyResolver(
             ILog logger,

src/ScriptCs.Core/AssemblyResolver.cs

@@ -2,17 +2,15 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Reflection.Emit;
 using Common.Logging;
-
 using ScriptCs.Contracts;
 
 namespace ScriptCs
 {
     public class AssemblyResolver : IAssemblyResolver
     {
         private readonly Dictionary<string, List<string>> _assemblyPathCache = new Dictionary<string, List<string>>();
- 
+
         private readonly IFileSystem _fileSystem;
 
         private readonly IPackageAssemblyResolver _packageAssemblyResolver;
@@ -62,7 +60,7 @@ public IEnumerable<string> GetAssemblyPaths(string path, bool binariesOnly = fal
             return assemblies;
         }
 
-        public IEnumerable<string> GetBinAssemblyPaths(string path)
+        private IEnumerable<string> GetBinAssemblyPaths(string path)
         {
             var binFolder = Path.Combine(path, _fileSystem.BinFolder);
             if (!_fileSystem.DirectoryExists(binFolder))

src/ScriptCs.Hosting/ModuleLoader.cs

@@ -5,8 +5,6 @@
 using System.IO;
 using System.Linq;
 using System.Reflection;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using Common.Logging;
 using ScriptCs.Contracts;
 
@@ -23,8 +21,8 @@ public class ModuleLoader : IModuleLoader
 
         [ImportingConstructor]
         public ModuleLoader(IAssemblyResolver resolver, ILog logger, IFileSystem fileSystem, IAssemblyUtility assemblyUtility) :
-            this(resolver, logger, null, null, fileSystem, assemblyUtility )
-        {         
+            this(resolver, logger, null, null, fileSystem, assemblyUtility)
+        {
         }
 
         public ModuleLoader(IAssemblyResolver resolver, ILog logger, Action<Assembly, AggregateCatalog> addToCatalog, Func<CompositionContainer, IEnumerable<Lazy<IModule, IModuleMetadata>>> getLazyModules, IFileSystem fileSystem, IAssemblyUtility assemblyUtility)
@@ -41,7 +39,7 @@ public ModuleLoader(IAssemblyResolver resolver, ILog logger, Action<Assembly, Ag
                         var assemblyCatalog = new AssemblyCatalog(assembly);
                         catalog.Catalogs.Add(assemblyCatalog);
                     }
-                    catch(Exception exception)
+                    catch (Exception exception)
                     {
                         logger.DebugFormat("Module Loader exception: {0}", exception.Message);
                     }
@@ -52,11 +50,9 @@ public ModuleLoader(IAssemblyResolver resolver, ILog logger, Action<Assembly, Ag
 
             if (getLazyModules == null)
             {
-                getLazyModules = (container) =>
-                {
-                    return container.GetExports<IModule, IModuleMetadata>();
-                };
+                getLazyModules = container => container.GetExports<IModule, IModuleMetadata>();
             }
+
             _getLazyModules = getLazyModules;
             _fileSystem = fileSystem;
             _assemblyUtility = assemblyUtility;
@@ -78,13 +74,17 @@ public void Load(IModuleConfiguration config, string[] modulePackagesPaths, stri
             InitializeModules(config, extension, moduleNames, lazyModules);
         }
 
-        private void InitializeModules(IModuleConfiguration config, string extension, string[] moduleNames,
+        private void InitializeModules(
+            IModuleConfiguration config,
+            string extension,
+            IEnumerable<string> moduleNames,
             IEnumerable<Lazy<IModule, IModuleMetadata>> lazyModules)
         {
             var modules = lazyModules
                 .Where(m => moduleNames.Contains(m.Metadata.Name) ||
                             (extension != null && m.Metadata.Extensions != null &&
-                             (m.Metadata.Extensions.Split(',').Contains(extension))) || m.Metadata.Autoload == true)
+                                (m.Metadata.Extensions.Split(',').Contains(extension))) ||
+                            m.Metadata.Autoload)
                 .Select(m => m.Value);
 
             _logger.Debug("Initializing modules");
@@ -98,7 +98,7 @@ private void InitializeModules(IModuleConfiguration config, string extension, st
             _logger.Debug("Modules initialized");
         }
 
-        private AggregateCatalog CreateAggregateCatalog(List<string> paths)
+        private AggregateCatalog CreateAggregateCatalog(IEnumerable<string> paths)
         {
             var catalog = new AggregateCatalog();
             foreach (var path in paths)
@@ -127,27 +127,24 @@ private AggregateCatalog CreateAggregateCatalog(List<string> paths)
             return catalog;
         }
 
-        private void AddPaths(string[] modulePackagesPaths, string hostBin, List<string> paths)
+        private void AddPaths(IEnumerable<string> modulePackagesPaths, string hostBin, List<string> paths)
         {
-            foreach (var modulePackagesPath in modulePackagesPaths)
+            foreach (var modulePaths in modulePackagesPaths
+                .Select(modulePackagesPath => _resolver.GetAssemblyPaths(modulePackagesPath, true)))
             {
-                var modulePaths = _resolver.GetAssemblyPaths(modulePackagesPath, true);
                 paths.AddRange(modulePaths);
             }
 
             if (hostBin != null)
             {
                 var assemblyPaths = _fileSystem.EnumerateBinaries(hostBin, SearchOption.TopDirectoryOnly);
-                foreach (var path in assemblyPaths)
-                {
-                    paths.Add(path);
-                }
+                paths.AddRange(assemblyPaths);
             }
         }
 
         private IEnumerable<Lazy<IModule, IModuleMetadata>> GetLazyModules(CompositionContainer container)
         {
-            IEnumerable<Lazy<IModule, IModuleMetadata>> lazyModules = null;
+            IEnumerable<Lazy<IModule, IModuleMetadata>> lazyModules;
 
             try
             {
@@ -166,8 +163,10 @@ private IEnumerable<Lazy<IModule, IModuleMetadata>> GetLazyModules(CompositionCo
                 {
                     _logger.DebugFormat("Module Loader exception:  {0}", exception.Message);
                 }
+
                 lazyModules = Enumerable.Empty<Lazy<IModule, IModuleMetadata>>();
             }
+
             return lazyModules;
         }
     }

test/ScriptCs.Core.Tests/AssemblyResolverTests.cs

@@ -110,7 +110,7 @@ public void ShouldOnlyReturnBinariesWhenFlagIsSet(
                 AssemblyResolver resolver)
             {
                 const string WorkingDirectory = @"C:\";
-               
+
                 var binFolder = Path.Combine(WorkingDirectory, "bin");
 
                 assemblyUtilityMock.Setup(a => a.IsManagedAssembly(It.IsAny<string>())).Returns(true);