Usefull.PullPackage 1.3.5

Usefull.PullPackage

.NET library for pulling NuGet packages and loading them dynamically in runtime.

Basic usage

Install NuGet package:

dotnet add package Usefull.PullPackage

Add using derective:

using Usefull.PullPackage;

Configure and build puller object:

using var puller = Puller.Build(config => config
    .Framework(FrameworkMoniker.net8_0)     // set target framework version
    .Package("System.Text.Json", "9.0.1")   // define packages to pull
    .Package("Humanizer.Core", "2.14.1")
    .Package("Npgsql", "9.0.2")
    .Source("local", "E:\\Work\\VisualStudio\\HDS\\.net\\.nuget\\") // define local folder source
        .WithMapping("Humanizer.Core")                              // define package which will be pulled from this source
    .Source("nuget.org", "https://api.nuget.org/v3/index.json")     // define nuget.org source
        .WithMapping("*")                                           // all other packages will be pulled from nuget.org
    .Directory("E:\\_TEMP\\")   // set target directory to pull
);

Perform pulling:

await puller.PullAsync();

Load all pulled assemblies:

var ctx = puller.LoadAll();

Then you can use loaded assemblies functionality by scripting:

using Microsoft.CodeAnalysis.CSharp.Scripting;
...
// Build script options and define imports (usings) for script
var options = ctx.BuildScriptOptions()
    .AddImports("System", "Humanizer");

// Invoke script and get result
var result = await CSharpScript.RunAsync("DateTime.UtcNow.AddHours(-2).Humanize()", options);

Or you can use it by reflection:

// Find assembly System.Text.Json.dll in pulled packages
var textJsonAssembly = ctx.GetAssemblies()
    .FirstOrDefault(a => a.FullName?.Contains("Text.Json") ?? false);

// Get type System.Text.Json.JsonSerializer
var jsonSerializerType = textJsonAssembly?.GetType("System.Text.Json.JsonSerializer");

// Get type System.Text.Json.JsonSerializerOptions
var jsonSerializerOptionsType = textJsonAssembly?.GetType("System.Text.Json.JsonSerializerOptions");

// Create instance of System.Text.Json.JsonSerializerOptions
var jsonSerializerOptions = Activator.CreateInstance(jsonSerializerOptionsType);

// Find method System.Text.Json.JsonSerializer.Serialize(object, Type, JsonSerializerOptions)
var serializeMethod = jsonSerializerType.GetMethod("Serialize", [typeof(object), typeof(Type), jsonSerializerOptionsType]);

// Invoke method
var result = serializeMethod.Invoke(null, [new Entity { Name = "Some entity", Value = 12 }, typeof(Entity), jsonSerializerOptions]);

Simplified usage by reflection:

// Attempt to create an instance of NpgsqlDataSourceBuilder
var dataSourceBuilder = ctx.CreateInstance(
    "Npgsql.NpgsqlDataSourceBuilder",
    ["Host=psqlhost;Port=5432;Username=user;Database=data;Password=pass"]);

// Build PostgreSQL data source and open connection
var dataSource = dataSourceBuilder.GetType().GetMethod("Build").Invoke(dataSourceBuilder, null);
var connection = dataSource.GetType().GetMethod("OpenConnection").Invoke(dataSource, null);

Unloading the context after use

In order to be able to unload after use, it is necessary to load assemblies into a �ollectible context:

var ctx = puller.LoadAll(true);

When the context is no longer needed initiate unloading by calling:

ctx.Unload();

However, this does not guarantee immediate release of the memory occupied by the context. To force unloading, use the following technique:

1. First, wrap all context operations, starting with loading, inside a single non-asynchronous method. Mark the method with an attribute MethodImplAttribute. This method, in addition to the necessary results, should return a weak reference to the context. For example, like this:

[MethodImpl(MethodImplOptions.NoInlining)]
private static (List<string>, WeakReference) GetAssembles(Puller puller)
{
    // Load all pulled assemblies
    var ctx = puller.LoadAll(true);

    // Read assemblies location.
    var result = puller.Packages.SelectMany(a => a.RuntimeAssemblies)
        .Select(a => a.Path).ToList();

    // Unload context
    ctx.Unload();           

    // Return result and the context weak redference
    return (result, new WeakReference(ctx));
}

2. After disposing the puller, force an immediately garbage collection and wait for the context finalized:

    using (var puller = Puller.Build( ... ))
    {
        await puller.PullAsync();
    
        // Do the necessary work with the context
        (var assys, ctxRef) = GetAssembles(puller);

        foreach(var assy in assys)
            Console.WriteLine(assy);
    }

    // Waiting for the context finalized
    while (ctxRef.IsAlive)
    {
        GC.Collect();
        GC.WaitForPendingFinalizers();
    }

Under certain conditions, the described approach allows for the complete unloading of the context. For more details see "Use collectible AssemblyLoadContext".

A full usage examples are available in our repository.