netcorehost

For custom signatures, define a delegate in C# and provide its assembly-qualified name to AssemblyDelegateLoader::get_function. The third argument to get_function should be the assembly-qualified name of the delegate type (e.g., "Namespace.ClassName+DelegateName, AssemblyName").

// C# Implementation
using System;

namespace Test {
    public static class Program {
        public delegate void CustomHelloFunc();
    
        public static void CustomHello() {
            Console.WriteLine("Hello from C!");
        }
    }
}

// Rust Implementation
let hostfxr = nethost::load_hostfxr().unwrap();
let context =
    hostfxr.initialize_for_runtime_config(pdcstr!("Test.runtimeconfig.json")).unwrap();
let fn_loader =
    context.get_delegate_loader_for_assembly(pdcstr!("Test.dll")).unwrap();
let hello = fn_loader.get_function::<fn()>(
    pdcstr!("Test.Program, Test"),
    pdcstr!("CustomHello"),
    pdcstr!("Test.Program+CustomHelloFunc, Test")
).unwrap();
hello(); // prints "Hello from C!"

Methods annotated with [UnmanagedCallersOnly] in C# can be loaded without specifying a signature because they cannot be overloaded. Use AssemblyDelegateLoader::get_function_with_unmanaged_callers_only::<T> where T is the function pointer type (e.g., fn()).

// C# Implementation
using System;
using System.Runtime.InteropServices;

namespace Test {
    public static class Program {
        [UnmanagedCallersOnly]
        public static void UnmanagedHello() {
            Console.WriteLine("Hello from C!");
        }
    }
}

// Rust Implementation
let hostfxr = nethost::load_hostfxr().unwrap();
let context =
    hostfxr.initialize_for_runtime_config(pdcstr!("Test.runtimeconfig.json")).unwrap();
let fn_loader =
    context.get_delegate_loader_for_assembly(pdcstr!("Test.dll")).unwrap();
let hello = fn_loader.get_function_with_unmanaged_callers_only::<fn()>(
    pdcstr!("Test.Program, Test"),
    pdcstr!("UnmanagedHello"),
).unwrap();
hello(); // prints "Hello from C!"

To call a managed method using the default signature, the C# method must match the following delegate shape:

public delegate int ComponentEntryPoint(IntPtr args, int sizeBytes);

In Rust, use Hostfxr::initialize_for_runtime_config to set up the context, obtain an AssemblyDelegateLoader via get_delegate_loader_for_assembly, and then use get_function_with_default_signature to retrieve the function pointer.

// C# Implementation
using System;

namespace Test {
    public static class Program {
        public static int Hello(IntPtr args, int sizeBytes) {
            Console.WriteLine("Hello from C!");
            return 42;
        }
    }
}

// Rust Implementation
let hostfxr = nethost::load_hostfxr().unwrap();
let context =
    hostfxr.initialize_for_runtime_config(pdcstr!("Test.runtimeconfig.json")).unwrap();
let fn_loader =
    context.get_delegate_loader_for_assembly(pdcstr!("Test.dll")).unwrap();
let hello = fn_loader.get_function_with_default_signature(
    pdcstr!("Test.Program, Test"),
    pdcstr!("Hello"),
).unwrap();
let result = unsafe { hello(std::ptr::null(), 0) };
assert_eq!(result, 42);

You can call managed methods that follow the default signature using AssemblyDelegateLoader::get_function_with_default_signature.

Default Signature (C#):

public delegate int ComponentEntryPoint(IntPtr args, int sizeBytes);

Requirements:

• The HostfxrContext must be initialized using Hostfxr::initialize_for_runtime_config (not initialize_for_dotnet_command_line).
• For libraries, ensure <GenerateRuntimeConfigurationFiles>True</GenerateRuntimeConfigurationFiles> is set in your .csproj file so the runtimeconfig.json is generated.

use netcorehost::{nethost, pdcstr};

let hostfxr = nethost::load_hostfxr().unwrap();
let context = hostfxr.initialize_for_runtime_config("path/to/runtimeconfig.json").unwrap();
let fn_loader = context.get_delegate_loader_for_assembly("path/to/Test.dll").unwrap();

// Load function with signature: (IntPtr, int)
let hello = fn_loader.get_function_with_default_signature(
    pdcstr!("Test.Program, Test"),
    pdcstr!("Hello"),
).unwrap();

// Call the function
let result = unsafe { hello(std::ptr::null(), 0) };

To initialize the .NET hosting environment, you can use the load_hostfxr family of functions. These functions combine locating the hostfxr library and loading it into the process, returning a Hostfxr instance.

Available loading strategies:

• load_hostfxr(): Uses default search logic.
• load_hostfxr_with_assembly_path(assembly_path): Locates hostfxr relative to the provided assembly.
• load_hostfxr_with_dotnet_root(dotnet_root): Locates hostfxr within the specified .NET installation directory.

Errors returned are of type LoadHostfxrError, which wraps either HostingError (errors from the .NET hosting components) or DlOpen errors (errors occurring during the dynamic library loading process).

use netcorehost::{load_hostfxr, load_hostfxr_with_assembly_path, load_hostfxr_with_dotnet_root};

// Load using default search
let hostfxr = load_hostfxr().expect("Failed to load hostfxr");

// Load relative to an assembly
let hostfxr = load_hostfxr_with_assembly_path("path/to/app.dll").expect("Failed to load hostfxr");

// Load using a specific .NET root
let hostfxr = load_hostfxr_with_dotnet_root("/usr/share/dotnet").expect("Failed to load hostfxr");