407 lines
16 KiB
C#
407 lines
16 KiB
C#
// Copyright (c) .NET Foundation. All rights reserved.
|
|
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using Microsoft.AspNetCore.Mvc.ApplicationParts;
|
|
using Microsoft.AspNetCore.Mvc.Core;
|
|
using Microsoft.Extensions.DependencyModel;
|
|
|
|
namespace Microsoft.AspNetCore.Mvc.Internal
|
|
{
|
|
// Discovers assemblies that are part of the MVC application using the DependencyContext.
|
|
public static class DefaultAssemblyPartDiscoveryProvider
|
|
{
|
|
private static readonly string PrecompiledViewsAssemblySuffix = ".PrecompiledViews";
|
|
private static readonly IReadOnlyList<string> ViewAssemblySuffixes = new string[]
|
|
{
|
|
PrecompiledViewsAssemblySuffix,
|
|
".Views",
|
|
};
|
|
|
|
private const string AdditionalReferenceKey = "Microsoft.AspNetCore.Mvc.AdditionalReference";
|
|
private static readonly char[] MetadataSeparators = new[] { ',' };
|
|
|
|
internal static HashSet<string> ReferenceAssemblies { get; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
|
|
{
|
|
"Microsoft.AspNetCore.All",
|
|
"Microsoft.AspNetCore.Mvc",
|
|
"Microsoft.AspNetCore.Mvc.Abstractions",
|
|
"Microsoft.AspNetCore.Mvc.ApiExplorer",
|
|
"Microsoft.AspNetCore.Mvc.Core",
|
|
"Microsoft.AspNetCore.Mvc.Cors",
|
|
"Microsoft.AspNetCore.Mvc.DataAnnotations",
|
|
"Microsoft.AspNetCore.Mvc.Formatters.Json",
|
|
"Microsoft.AspNetCore.Mvc.Formatters.Xml",
|
|
"Microsoft.AspNetCore.Mvc.Localization",
|
|
"Microsoft.AspNetCore.Mvc.Razor",
|
|
"Microsoft.AspNetCore.Mvc.Razor.Extensions",
|
|
"Microsoft.AspNetCore.Mvc.RazorPages",
|
|
"Microsoft.AspNetCore.Mvc.TagHelpers",
|
|
"Microsoft.AspNetCore.Mvc.ViewFeatures"
|
|
};
|
|
|
|
// For testing purposes only.
|
|
internal static Func<string, Assembly> AssemblyLoader { get; set; } = Assembly.LoadFile;
|
|
internal static Func<string, bool> AssemblyResolver { get; set; } = File.Exists;
|
|
|
|
public static IEnumerable<ApplicationPart> DiscoverAssemblyParts(string entryPointAssemblyName)
|
|
{
|
|
// We need to produce a stable order of the parts that is given by:
|
|
// 1) Parts that are not additional parts go before parts that are additional parts.
|
|
// 2) The entry point part goes before any other part in the system.
|
|
// 3) The entry point additional parts go before any other additional parts.
|
|
// 4) Parts are finally ordered by their full name to produce a stable ordering.
|
|
var entryAssembly = Assembly.Load(new AssemblyName(entryPointAssemblyName));
|
|
var context = DependencyContext.Load(entryAssembly);
|
|
|
|
var candidateAssemblies = new SortedSet<Assembly>(
|
|
GetCandidateAssemblies(entryAssembly, context),
|
|
FullNameAssemblyComparer.Instance);
|
|
|
|
var (additionalReferences, entryAssemblyAdditionalReferences) = ResolveAdditionalReferences(
|
|
entryAssembly,
|
|
candidateAssemblies);
|
|
|
|
candidateAssemblies.Remove(entryAssembly);
|
|
candidateAssemblies.ExceptWith(additionalReferences);
|
|
candidateAssemblies.ExceptWith(entryAssemblyAdditionalReferences);
|
|
|
|
// Create the list of assembly parts.
|
|
return CreateParts();
|
|
|
|
IEnumerable<AssemblyPart> CreateParts()
|
|
{
|
|
yield return new AssemblyPart(entryAssembly);
|
|
foreach (var candidateAssembly in candidateAssemblies)
|
|
{
|
|
yield return new AssemblyPart(candidateAssembly);
|
|
}
|
|
foreach (var entryAdditionalAssembly in entryAssemblyAdditionalReferences)
|
|
{
|
|
yield return new AdditionalAssemblyPart(entryAdditionalAssembly);
|
|
}
|
|
foreach (var additionalAssembly in additionalReferences)
|
|
{
|
|
yield return new AdditionalAssemblyPart(additionalAssembly);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal static AdditionalReferencesPair ResolveAdditionalReferences(
|
|
Assembly entryAssembly,
|
|
SortedSet<Assembly> candidateAssemblies)
|
|
{
|
|
var additionalAssemblyReferences = candidateAssemblies
|
|
.Select(ca =>
|
|
(assembly: ca,
|
|
metadata: ca.GetCustomAttributes<AssemblyMetadataAttribute>()
|
|
.Where(ama => ama.Key.Equals(AdditionalReferenceKey, StringComparison.Ordinal)).ToArray()));
|
|
|
|
// Find out all the additional references defined by the assembly.
|
|
// [assembly: AssemblyMetadataAttribute("Microsoft.AspNetCore.Mvc.AdditionalReference", "Library.PrecompiledViews.dll,true|false")]
|
|
var additionalReferences = new SortedSet<Assembly>(FullNameAssemblyComparer.Instance);
|
|
var entryAssemblyAdditionalReferences = new SortedSet<Assembly>(FullNameAssemblyComparer.Instance);
|
|
foreach (var (assembly, metadata) in additionalAssemblyReferences)
|
|
{
|
|
if (metadata.Length > 0)
|
|
{
|
|
foreach (var metadataAttribute in metadata)
|
|
{
|
|
AddAdditionalReference(
|
|
LoadFromMetadata(assembly, metadataAttribute),
|
|
entryAssembly,
|
|
assembly,
|
|
additionalReferences,
|
|
entryAssemblyAdditionalReferences);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Fallback to loading the views like in previous versions if the additional reference metadata
|
|
// attribute is not present.
|
|
AddAdditionalReference(
|
|
LoadFromConvention(assembly),
|
|
entryAssembly,
|
|
assembly,
|
|
additionalReferences,
|
|
entryAssemblyAdditionalReferences);
|
|
}
|
|
}
|
|
|
|
return new AdditionalReferencesPair
|
|
{
|
|
AdditionalAssemblies = additionalReferences,
|
|
EntryAssemblyAdditionalAssemblies = entryAssemblyAdditionalReferences
|
|
};
|
|
}
|
|
|
|
private static Assembly LoadFromMetadata(Assembly assembly, AssemblyMetadataAttribute metadataAttribute)
|
|
{
|
|
var (metadataPath, metadataIncludeByDefault) = ParseMetadataAttribute(metadataAttribute);
|
|
if (metadataPath == null ||
|
|
metadataIncludeByDefault == null ||
|
|
!string.Equals(metadataIncludeByDefault, "true", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var fileName = Path.GetFileName(metadataPath);
|
|
var filePath = Path.Combine(Path.GetDirectoryName(assembly.Location), fileName);
|
|
var additionalAssembly = LoadAssembly(filePath);
|
|
|
|
if (additionalAssembly == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return additionalAssembly;
|
|
}
|
|
|
|
private static (string metadataPath, string metadataIncludeByDefault) ParseMetadataAttribute(
|
|
AssemblyMetadataAttribute metadataAttribute)
|
|
{
|
|
var data = metadataAttribute.Value.Split(MetadataSeparators);
|
|
if (data.Length != 2 || string.IsNullOrWhiteSpace(data[0]) || string.IsNullOrWhiteSpace(data[1]))
|
|
{
|
|
return default;
|
|
}
|
|
|
|
return (data[0], data[1]);
|
|
}
|
|
|
|
private static Assembly LoadAssembly(string filePath)
|
|
{
|
|
Assembly viewsAssembly = null;
|
|
if (AssemblyResolver(filePath))
|
|
{
|
|
try
|
|
{
|
|
viewsAssembly = AssemblyLoader(filePath);
|
|
}
|
|
catch (FileLoadException)
|
|
{
|
|
// Don't throw if assembly cannot be loaded. This can happen if the file is not a managed assembly.
|
|
}
|
|
}
|
|
|
|
return viewsAssembly;
|
|
}
|
|
|
|
private static Assembly LoadFromConvention(Assembly assembly)
|
|
{
|
|
if (assembly.IsDynamic || string.IsNullOrEmpty(assembly.Location))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
for (var i = 0; i < ViewAssemblySuffixes.Count; i++)
|
|
{
|
|
var fileName = assembly.GetName().Name + ViewAssemblySuffixes[i] + ".dll";
|
|
var filePath = Path.Combine(Path.GetDirectoryName(assembly.Location), fileName);
|
|
|
|
var viewsAssembly = LoadAssembly(filePath);
|
|
if (viewsAssembly != null)
|
|
{
|
|
return viewsAssembly;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private static void AddAdditionalReference(
|
|
Assembly additionalReference,
|
|
Assembly entryAssembly,
|
|
Assembly assembly,
|
|
SortedSet<Assembly> additionalReferences,
|
|
SortedSet<Assembly> entryAssemblyAdditionalReferences)
|
|
{
|
|
if (additionalReference == null ||
|
|
additionalReferences.Contains(additionalReference) ||
|
|
entryAssemblyAdditionalReferences.Contains(additionalReference))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (assembly.Equals(entryAssembly))
|
|
{
|
|
entryAssemblyAdditionalReferences.Add(additionalReference);
|
|
}
|
|
else
|
|
{
|
|
additionalReferences.Add(additionalReference);
|
|
}
|
|
}
|
|
|
|
internal class AdditionalReferencesPair
|
|
{
|
|
public SortedSet<Assembly> AdditionalAssemblies { get; set; }
|
|
public SortedSet<Assembly> EntryAssemblyAdditionalAssemblies { get; set; }
|
|
|
|
public void Deconstruct(
|
|
out SortedSet<Assembly> additionalAssemblies,
|
|
out SortedSet<Assembly> entryAssemblyAdditionalAssemblies)
|
|
{
|
|
additionalAssemblies = AdditionalAssemblies;
|
|
entryAssemblyAdditionalAssemblies = EntryAssemblyAdditionalAssemblies;
|
|
}
|
|
}
|
|
|
|
internal class FullNameAssemblyComparer : IComparer<Assembly>
|
|
{
|
|
public static IComparer<Assembly> Instance { get; } = new FullNameAssemblyComparer();
|
|
|
|
public int Compare(Assembly x, Assembly y) =>
|
|
string.Compare(x?.FullName, y?.FullName, StringComparison.Ordinal);
|
|
}
|
|
|
|
internal static IEnumerable<Assembly> GetCandidateAssemblies(Assembly entryAssembly, DependencyContext dependencyContext)
|
|
{
|
|
if (dependencyContext == null)
|
|
{
|
|
// Use the entry assembly as the sole candidate.
|
|
return new[] { entryAssembly };
|
|
}
|
|
|
|
return GetCandidateLibraries(dependencyContext)
|
|
.SelectMany(library => library.GetDefaultAssemblyNames(dependencyContext))
|
|
.Select(Assembly.Load);
|
|
}
|
|
|
|
// Returns a list of libraries that references the assemblies in <see cref="ReferenceAssemblies"/>.
|
|
// By default it returns all assemblies that reference any of the primary MVC assemblies
|
|
// while ignoring MVC assemblies.
|
|
// Internal for unit testing
|
|
internal static IEnumerable<RuntimeLibrary> GetCandidateLibraries(DependencyContext dependencyContext)
|
|
{
|
|
if (ReferenceAssemblies == null)
|
|
{
|
|
return Enumerable.Empty<RuntimeLibrary>();
|
|
}
|
|
|
|
var candidatesResolver = new CandidateResolver(dependencyContext.RuntimeLibraries, ReferenceAssemblies);
|
|
return candidatesResolver.GetCandidates();
|
|
}
|
|
|
|
private class CandidateResolver
|
|
{
|
|
private readonly IDictionary<string, Dependency> _runtimeDependencies;
|
|
|
|
public CandidateResolver(IReadOnlyList<RuntimeLibrary> runtimeDependencies, ISet<string> referenceAssemblies)
|
|
{
|
|
var dependenciesWithNoDuplicates = new Dictionary<string, Dependency>(StringComparer.OrdinalIgnoreCase);
|
|
foreach (var dependency in runtimeDependencies)
|
|
{
|
|
if (dependenciesWithNoDuplicates.ContainsKey(dependency.Name))
|
|
{
|
|
throw new InvalidOperationException(Resources.FormatCandidateResolver_DifferentCasedReference(dependency.Name));
|
|
}
|
|
dependenciesWithNoDuplicates.Add(dependency.Name, CreateDependency(dependency, referenceAssemblies));
|
|
}
|
|
|
|
_runtimeDependencies = dependenciesWithNoDuplicates;
|
|
}
|
|
|
|
private Dependency CreateDependency(RuntimeLibrary library, ISet<string> referenceAssemblies)
|
|
{
|
|
var classification = DependencyClassification.Unknown;
|
|
if (referenceAssemblies.Contains(library.Name))
|
|
{
|
|
classification = DependencyClassification.MvcReference;
|
|
}
|
|
|
|
return new Dependency(library, classification);
|
|
}
|
|
|
|
private DependencyClassification ComputeClassification(string dependency)
|
|
{
|
|
if (!_runtimeDependencies.ContainsKey(dependency))
|
|
{
|
|
// Library does not have runtime dependency. Since we can't infer
|
|
// anything about it's references, we'll assume it does not have a reference to Mvc.
|
|
return DependencyClassification.DoesNotReferenceMvc;
|
|
}
|
|
|
|
var candidateEntry = _runtimeDependencies[dependency];
|
|
if (candidateEntry.Classification != DependencyClassification.Unknown)
|
|
{
|
|
return candidateEntry.Classification;
|
|
}
|
|
else
|
|
{
|
|
var classification = DependencyClassification.DoesNotReferenceMvc;
|
|
foreach (var candidateDependency in candidateEntry.Library.Dependencies)
|
|
{
|
|
var dependencyClassification = ComputeClassification(candidateDependency.Name);
|
|
if (dependencyClassification == DependencyClassification.ReferencesMvc ||
|
|
dependencyClassification == DependencyClassification.MvcReference)
|
|
{
|
|
classification = DependencyClassification.ReferencesMvc;
|
|
break;
|
|
}
|
|
}
|
|
|
|
candidateEntry.Classification = classification;
|
|
|
|
return classification;
|
|
}
|
|
}
|
|
|
|
public IEnumerable<RuntimeLibrary> GetCandidates()
|
|
{
|
|
foreach (var dependency in _runtimeDependencies)
|
|
{
|
|
if (ComputeClassification(dependency.Key) == DependencyClassification.ReferencesMvc)
|
|
{
|
|
yield return dependency.Value.Library;
|
|
}
|
|
}
|
|
}
|
|
|
|
private class Dependency
|
|
{
|
|
public Dependency(RuntimeLibrary library, DependencyClassification classification)
|
|
{
|
|
Library = library;
|
|
Classification = classification;
|
|
}
|
|
|
|
public RuntimeLibrary Library { get; }
|
|
|
|
public DependencyClassification Classification { get; set; }
|
|
|
|
public override string ToString()
|
|
{
|
|
return $"Library: {Library.Name}, Classification: {Classification}";
|
|
}
|
|
}
|
|
|
|
private enum DependencyClassification
|
|
{
|
|
Unknown = 0,
|
|
|
|
/// <summary>
|
|
/// References (directly or transitively) one of the Mvc packages listed in
|
|
/// <see cref="ReferenceAssemblies"/>.
|
|
/// </summary>
|
|
ReferencesMvc = 1,
|
|
|
|
/// <summary>
|
|
/// Does not reference (directly or transitively) one of the Mvc packages listed by
|
|
/// <see cref="ReferenceAssemblies"/>.
|
|
/// </summary>
|
|
DoesNotReferenceMvc = 2,
|
|
|
|
/// <summary>
|
|
/// One of the references listed in <see cref="ReferenceAssemblies"/>.
|
|
/// </summary>
|
|
MvcReference = 3,
|
|
}
|
|
}
|
|
}
|
|
}
|