Make mono run as .NET 4.5.1

- Turns out mono's 4.5 profile (for the versions of mono we support)
is actually compatible with .NET 4.5.1.
- Fix problem with compiling against reference assemblies
that were not resolved via dependency resolution.

#511
#374

src/Microsoft.Framework.Runtime/DependencyManagement/ReferenceAssemblyDependencyResolver.cs

@@ -71,6 +71,17 @@ public void Initialize(IEnumerable<LibraryDescription> dependencies, FrameworkNa
 
         public ILibraryExport GetLibraryExport(string name, FrameworkName targetFramework, string configuration)
         {
+            // Did we even resolve this name, if not then do nothing
+            if (!_resolvedPaths.ContainsKey(name))
+            {
+                return null;
+            }
+
+            // We can't use resolved paths since it might be different to the target framework
+            // being passed in here. After we know this resolver is handling the 
+            // requested name, we can call back into the FrameworkResolver to figure out
+            //  the specific path for the target framework
+
             string path;
             if (FrameworkResolver.TryGetAssembly(name, targetFramework, out path))
             {

src/Microsoft.Framework.Runtime/FrameworkReferenceResolver.cs

@@ -33,7 +33,7 @@ public bool TryGetAssembly(string name, FrameworkName targetFramework, out strin
 
             lock (information.Assemblies)
             {
-                if (information.Assemblies.TryGetValue(name, out path) && 
+                if (information.Assemblies.TryGetValue(name, out path) &&
                     string.IsNullOrEmpty(path))
                 {
                     path = GetAssemblyPath(information.Path, name);
@@ -100,34 +100,51 @@ private void PopulateCache()
 
                 var libPath = Path.GetDirectoryName(Path.GetDirectoryName(mscorlibLocationOnThisRunningMonoInstance));
 
-                var supportedVersions = new[] { "4.5", "4.0" };
+                // Mono is a bit inconsistent as .NET 4.5 and .NET 4.5.1 are the
+                // same folder
+                var supportedVersions = new Dictionary<string, string> {
+                    { "4.5.1", "4.5" },
+                    { "4.5", "4.5" },
+                    { "4.0", "4.0" }
+                };
 
-                foreach (var version in supportedVersions)
+                // Temporary cache while enumerating assemblies in directories
+                var pathCache = new Dictionary<string, FrameworkInformation>();
+
+                foreach (var versionFolderPair in supportedVersions)
                 {
-                    var targetFrameworkPath = Path.Combine(libPath, version);
+                    var targetFrameworkPath = Path.Combine(libPath, versionFolderPair.Value);
 
                     if (!Directory.Exists(targetFrameworkPath))
                     {
                         continue;
                     }
 
-                    var frameworkName = new FrameworkName(VersionUtility.DefaultTargetFramework.Identifier, new Version(version));
+                    FrameworkInformation frameworkInfo;
+                    if (!pathCache.TryGetValue(targetFrameworkPath, out frameworkInfo))
+                    {
+                        frameworkInfo = new FrameworkInformation();
+                        frameworkInfo.Path = targetFrameworkPath;
 
-                    var frameworkInfo = new FrameworkInformation();
-                    frameworkInfo.Path = targetFrameworkPath;
+                        var assemblies = new List<Tuple<string, string>>();
 
-                    var assemblies = new List<Tuple<string, string>>();
+                        PopulateAssemblies(assemblies, targetFrameworkPath);
+                        PopulateAssemblies(assemblies, Path.Combine(targetFrameworkPath, "Facades"));
 
-                    PopulateAssemblies(assemblies, targetFrameworkPath);
-                    PopulateAssemblies(assemblies, Path.Combine(targetFrameworkPath, "Facades"));
+                        foreach (var pair in assemblies)
+                        {
+                            frameworkInfo.Assemblies[pair.Item1] = pair.Item2;
+                        }
 
-                    foreach (var pair in assemblies)
-                    {
-                        frameworkInfo.Assemblies[pair.Item1] = pair.Item2;
+                        pathCache[targetFrameworkPath] = frameworkInfo;
                     }
 
+                    var frameworkName = new FrameworkName(VersionUtility.DefaultTargetFramework.Identifier, new Version(versionFolderPair.Key));
                     _cache[frameworkName] = frameworkInfo;
                 }
+
+                // Not needed anymore
+                pathCache.Clear();
             }
 #endif
         }

src/klr.host/Bootstrapper.cs

@@ -56,7 +56,8 @@ public Task<int> Main(string[] args)
             var framework = Environment.GetEnvironmentVariable("TARGET_FRAMEWORK") ?? Environment.GetEnvironmentVariable("KRE_FRAMEWORK");
             var configuration = Environment.GetEnvironmentVariable("TARGET_CONFIGURATION") ?? Environment.GetEnvironmentVariable("KRE_CONFIGURATION") ?? "Debug";
 
-            var targetFramework = FrameworkNameUtility.ParseFrameworkName(framework ?? (PlatformHelper.IsMono ? "net45" : "net451"));
+            // TODO: Support the highest installed version
+            var targetFramework = FrameworkNameUtility.ParseFrameworkName("net451");
 
             var applicationEnvironment = new ApplicationEnvironment(applicationBaseDirectory,
                                                                     targetFramework,