如何在.NET中实现动态FFI？F#解释器调用C函数方案咨询

方案一：动态生成IL实现P/Invoke调用 #

这是纯.NET生态内的方案，无需依赖第三方库，核心思路是利用System.Reflection.Emit动态生成匹配目标C函数签名的委托类型，再结合.NET的Interop机制完成调用。

实现步骤： #

1. 解析运行时签名：从解释器输入中提取函数的返回类型、参数类型、调用约定（如cdecl/stdcall）、动态库路径及函数名。
2. 动态生成委托类型：通过TypeBuilder创建对应签名的委托类型（Marshal.GetDelegateForFunctionPointer要求委托类型与C函数签名完全匹配）。
3. 加载库并获取函数指针：用NativeLibrary.Load加载目标动态库，再通过NativeLibrary.GetExport获取函数的内存指针。
4. 绑定委托并执行调用：将函数指针转换为动态生成的委托实例，直接调用即可。

F#示例代码片段： #

open System
open System.Reflection
open System.Reflection.Emit
open System.Runtime.InteropServices

let createDelegateType (returnType: Type) (paramTypes: Type[]) (callingConvention: CallingConvention) =
    let assemblyName = AssemblyName("DynamicDelegates")
    let assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run)
    let moduleBuilder = assemblyBuilder.DefineDynamicModule("DynamicModule")
    let delegateBuilder = moduleBuilder.DefineType(
        $"DynamicDelegate_{Guid.NewGuid():N}",
        TypeAttributes.Public ||| TypeAttributes.Sealed ||| TypeAttributes.Class,
        typeof<MulticastDelegate>
    )
    // 定义委托构造函数
    let ctor = delegateBuilder.DefineConstructor(
        MethodAttributes.RTSpecialName ||| MethodAttributes.HideBySig ||| MethodAttributes.Public,
        CallingConventions.Standard,
        [| typeof<obj>; typeof<nativeint> |]
    )
    ctor.SetImplementationFlags(MethodImplAttributes.Runtime ||| MethodImplAttributes.Managed)
    // 定义Invoke方法
    let invokeMethod = delegateBuilder.DefineMethod(
        "Invoke",
        MethodAttributes.Public ||| MethodAttributes.HideBySig ||| MethodAttributes.Virtual,
        returnType,
        paramTypes
    )
    invokeMethod.SetImplementationFlags(MethodImplAttributes.Runtime ||| MethodImplAttributes.Managed)
    invokeMethod.SetCallingConvention(callingConvention)
    delegateBuilder.CreateType()

// 示例：动态调用C标准库的printf
let libPath = if Environment.OSVersion.Platform = PlatformID.Win32NT then "msvcrt.dll" else "libc.so.6"
let funcName = "printf"
let returnType = typeof<int>
let paramTypes = [| typeof<string>; typeof<int> |]
let callingConvention = CallingConvention.Cdecl

use lib = NativeLibrary.Load(libPath)
let funcPtr = NativeLibrary.GetExport(lib, funcName)

let delegateType = createDelegateType returnType paramTypes callingConvention
let del = Marshal.GetDelegateForFunctionPointer(funcPtr, delegateType)

// 执行调用：printf("Number: %d\n", 42)
del.DynamicInvoke("Number: %d\n", 42) |> ignore

优缺点： #

• 优点：纯.NET实现，无需额外编译C代码，性能接近静态P/Invoke，兼容.NET支持的所有平台。
• 缺点：需要熟悉IL生成和.NET调用约定细节，处理结构体、复杂指针类型时需额外处理内存布局。

方案二：自行封装libffi实现动态调用 #

若需要支持非标准调用约定，或不想处理IL生成逻辑，可以自行封装libffi核心功能为小型C库，再通过静态P/Invoke让F#调用该封装层。

实现步骤： #

1. 编写libffi封装层：用C语言实现轻量wrapper，暴露ffi_call的核心能力，接收函数指针、参数类型数组、参数值数组、返回值指针等参数。
2. 跨平台编译封装库：针对Windows/macOS/Linux分别编译为.dll/.dylib/.so动态库。
3. F#中调用封装库：通过静态P/Invoke调用封装函数，在解释器运行时传递签名信息与参数，完成动态调用。

简化C封装示例： #

#include <ffi.h>

void dynamic_call(void* func_ptr, ffi_type* ret_type, ffi_type** arg_types, void** args, void* ret_val) {
    ffi_cif cif;
    if (ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 0, ret_type, arg_types) == FFI_OK) {
        ffi_call(&cif, FFI_FN(func_ptr), ret_val, args);
    }
}

F#调用关键片段： #

open System.Runtime.InteropServices

[<DllImport("libffi_wrapper.so")>]
extern void dynamic_call(nativeint func_ptr, nativeint ret_type, nativeint[] arg_types, nativeint[] args, nativeint ret_val)

// 运行时构造ffi_type指针数组、参数指针数组后，调用dynamic_call即可

优缺点： #

• 优点：复用libffi成熟的动态调用能力，支持几乎所有C语言调用约定与类型，无需处理.NET IL生成细节。
• 缺点：需维护跨平台C库编译，增加项目复杂度，性能略低于纯.NET方案。

方案三：利用.NET 7+增强Native API（进阶） #

.NET 7及以上对System.Runtime.InteropServices.NativeLibrary做了增强，配合System.Reflection.Emit的优化，可以更简洁地生成动态P/Invoke方法，本质是方案一的简化版，核心逻辑一致，但减少了样板代码。

内容的提问来源于stack exchange，提问作者Foxy