Anvisningar: Granska sammansättningsinnehåll med metadataLoadContext

Reflektions-API:et i .NET gör det som standard möjligt för utvecklare att inspektera innehållet i sammansättningar som läses in i huvudkörningskontexten. Ibland går det dock inte att läsa in en sammansättning i körningskontexten, till exempel för att den kompilerats för en annan plattform eller processorarkitektur, eller så är det en referenssammansättning. Med API:et System.Reflection.MetadataLoadContext kan du läsa in och inspektera sådana sammansättningar. Sammansättningar som läses in i MetadataLoadContext behandlas endast som metadata, dvs. du kan undersöka typer i sammansättningen, men du kan inte köra någon kod som finns i den. Till skillnad från huvudkörningskontexten, så läser MetadataLoadContext inte in beroendena automatiskt från den aktuella katalogen. Istället använder det den anpassade bindningslogik som tillhandahålls av MetadataAssemblyResolver som skickas till det.

Förutsättningar

Om du vill använda MetadataLoadContextinstallerar du NuGet-paketet System.Reflection.MetadataLoadContext . Det stöds i alla .NET Standard 2.0-kompatibla målramverk, till exempel .NET Core 2.0 eller .NET Framework 4.6.1.

Skapa MetadataAssemblyResolver för MetadataLoadContext

För att skapa MetadataLoadContext måste du tillhandahålla instansen av MetadataAssemblyResolver. Det enklaste sättet att ange ett är att använda PathAssemblyResolver, som löser sammansättningar från den angivna samlingen med strängar för sammansättningssökväg. Den här samlingen, utöver de moduler du vill inspektera direkt, bör även innehålla alla nödvändiga beroenden. Om du till exempel vill läsa det anpassade attributet som finns i en extern sammansättning bör du inkludera den sammansättningen eller så genereras ett undantag. I de flesta fall bör du inkludera åtminstone kärnsammansättningen, dvs. sammansättningen som innehåller inbyggda systemtyper, till exempel System.Object. Följande kod visar hur du skapar PathAssemblyResolver med hjälp av samlingen som består av den inspekterade assemblyn och den aktuella körningens kärnassembly.

var resolver = new PathAssemblyResolver(new string[] { "ExampleAssembly.dll", typeof(object).Assembly.Location });

Om du behöver åtkomst till alla BCL-typer kan du inkludera alla körningsmiljömonteringar i samlingen. Följande kod visar hur du skapar PathAssemblyResolver med hjälp av samlingen som består av det inspekterade assemblyt och alla assemblies i den aktuella runtime-miljön.

// Get the array of runtime assemblies.
string[] runtimeAssemblies = Directory.GetFiles(RuntimeEnvironment.GetRuntimeDirectory(), "*.dll");

// Create the list of assembly paths consisting of runtime assemblies and the inspected assembly.
var paths = new List<string>(runtimeAssemblies);
paths.Add("ExampleAssembly.dll");

// Create PathAssemblyResolver that can resolve assemblies using the created list.
var resolver = new PathAssemblyResolver(paths);

Skapa MetadataLoadContext

Om du vill skapa MetadataLoadContextanropar du konstruktorn MetadataLoadContext(MetadataAssemblyResolver, String)och skickar den tidigare skapade MetadataAssemblyResolver som den första parametern och kärnsammansättningens namn som den andra parametern. Du kan utelämna huvudsammansättningens namn, i vilket fall konstruktorn försöker använda standardnamnen: "mscorlib", "System.Runtime" eller "netstandard".

När du har skapat kontexten kan du läsa in sammansättningar i den med metoder som LoadFromAssemblyPath. Du kan använda alla reflektions-API:er för inlästa sammansättningar förutom de som omfattar kodkörning. Metoden GetCustomAttributes omfattar körning av konstruktorer, så använd GetCustomAttributesData metoden i stället när du behöver undersöka anpassade attribut i MetadataLoadContext.

Följande kodexempel skapar MetadataLoadContext, läser in sammansättningen i den och matar ut sammansättningsattribut till konsolen:

var mlc = new MetadataLoadContext(resolver);

using (mlc)
{
    // Load assembly into MetadataLoadContext.
    Assembly assembly = mlc.LoadFromAssemblyPath("ExampleAssembly.dll");
    AssemblyName name = assembly.GetName();

    // Print assembly attribute information.
    Console.WriteLine($"{name.Name} has following attributes: ");

    foreach (CustomAttributeData attr in assembly.GetCustomAttributesData())
    {
        try
        {
            Console.WriteLine(attr.AttributeType);
        }
        catch (FileNotFoundException ex)
        {
            // We are missing the required dependency assembly.
            Console.WriteLine($"Error while getting attribute type: {ex.Message}");
        }
    }
}

Om du behöver testa typer i MetadataLoadContext för likhet eller tilldelning bör du endast använda typobjekt som har lästs in i den kontexten. Att blanda MetadataLoadContext typer med körtyper stöds inte. Överväg till exempel en typ testedType i MetadataLoadContext. Om du behöver testa om en annan typ kan tilldelas från den ska du inte använda kod som typeof(MyType).IsAssignableFrom(testedType). Använd kod som den här i stället:

Assembly matchAssembly = mlc.LoadFromAssemblyPath(typeof(MyType).Assembly.Location);
Type matchType = assembly.GetType(typeof(MyType).FullName!)!;

if (matchType.IsAssignableFrom(testedType))
{
    Console.WriteLine($"{nameof(matchType)} is assignable from {nameof(testedType)}");
}

Example

Ett fullständigt kodexempel finns i exemplet Granska sammansättningsinnehåll med metadataLoadContext.

Se även

• Reflektion i .NET