stecken einige RC1 Code RC2

Question

In RC1 Umwandlung:

_libraryManager.GetLibraries().SelectMany(l => l.Assemblies).Distinct().ToList(); 

In RC2, scheint es keine API zur Verfügung stehen, zu erhalten die Assemblies einer Bibliothek.

Ich habe die Ankündigung gelesen: https://github.com/aspnet/Announcements/issues/149 und diese Ankündigung erläutert nur, wie die Abhängigkeiten einer Assembly abgerufen werden, es erläutert nicht, wie die Assemblys einer Bibliothek abgerufen werden, jetzt, da die Assemblies-Eigenschaft veraltet ist.

Wer hat irgendwelche Ideen?

Ich habe warf auch ein Github Problem hier https://github.com/aspnet/Home/issues/1554

Answer 1

Die Lösung laden Wenn Sie von RC1 zu RC2 wechseln, müssen Sie ILibraryManager entfernen und die neuen Ersetzungen (DependencyContext) verwenden. Sehen Sie, wie MVC6 tut es hier:

https://github.com/aspnet/Mvc/blob/dev/src/Microsoft.AspNetCore.Mvc.Core/Internal/DefaultAssemblyPartDiscoveryProvider.cs#L55-L158

Ich werde den Quellcode hier enthalten, obwohl auch in dem Fall, dass aus irgendeinem Grund geht weg verlinken:

// Discovers assemblies that are part of the MVC application using the DependencyContext. 
public static class DefaultAssemblyPartDiscoveryProvider 
{ 
    internal static HashSet<string> ReferenceAssemblies { get; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase) 
    { 
     "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.Host", 
     "Microsoft.AspNetCore.Mvc.TagHelpers", 
     "Microsoft.AspNetCore.Mvc.ViewFeatures" 
    }; 

    public static IEnumerable<ApplicationPart> DiscoverAssemblyParts(string entryPointAssemblyName) 
    { 
     var entryAssembly = Assembly.Load(new AssemblyName(entryPointAssemblyName)); 
     var context = DependencyContext.Load(Assembly.Load(new AssemblyName(entryPointAssemblyName))); 

     return GetCandidateAssemblies(entryAssembly, context).Select(p => new AssemblyPart(p)); 
    } 

    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> _dependencies; 

     public CandidateResolver(IReadOnlyList<RuntimeLibrary> dependencies, ISet<string> referenceAssemblies) 
     { 
      _dependencies = dependencies 
       .ToDictionary(d => d.Name, d => CreateDependency(d, referenceAssemblies), StringComparer.OrdinalIgnoreCase); 
     } 

     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) 
     { 
      Debug.Assert(_dependencies.ContainsKey(dependency)); 

      var candidateEntry = _dependencies[dependency]; 
      if (candidateEntry.Classification != DependencyClassification.Unknown) 
      { 
       return candidateEntry.Classification; 
      } 
      else 
      { 
       var classification = DependencyClassification.NotCandidate; 
       foreach (var candidateDependency in candidateEntry.Library.Dependencies) 
       { 
        var dependencyClassification = ComputeClassification(candidateDependency.Name); 
        if (dependencyClassification == DependencyClassification.Candidate || 
         dependencyClassification == DependencyClassification.MvcReference) 
        { 
         classification = DependencyClassification.Candidate; 
         break; 
        } 
       } 

       candidateEntry.Classification = classification; 

       return classification; 
      } 
     } 

     public IEnumerable<RuntimeLibrary> GetCandidates() 
     { 
      foreach (var dependency in _dependencies) 
      { 
       if (ComputeClassification(dependency.Key) == DependencyClassification.Candidate) 
       { 
        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, 
      Candidate = 1, 
      NotCandidate = 2, 
      MvcReference = 3 
     } 
    } 
} 

Answer 2

Sie Baugruppen über etwas bekommen könnte wie folgt aus:

libManager.GetLibraries() 
    .Where(x => x.Identity.Type == LibraryType.Project) 
    .Select(x => Assembly.Load(new AssemblyName(x.Identity.Name))).ToList(); 

Dies sollte alle Projektreferenzen bekommen und die Baugruppen