如何在F#中创建含指定长度数组的参数化类型？

问题背景 #

我定义了如下F#类型：

[<CLIMutable>]
type MLDataRow =
    {
        [<ColumnName "Label"; LoadColumn(0)>]
        Label: bool
        [<ColumnName "Features"; VectorType(799); LoadColumn(1, 799)>]
        Features: float32 array
    }

    static member Build (label, features: float32 array) = { Label = label; Features = features }

我希望将Features字段特性里的799改为可传入的参数，比如通过类似let a = MLDataRow.Build (10, true, myData)的方式，生成特性参数为10的对应类型。我猜测需要用反射实现，但不清楚具体操作方法，求指教。

解决方案 #

F#编译时特性无法直接在运行时修改，但可以通过运行时动态生成类型的方式实现需求，核心是利用.NET的System.Reflection.Emit API构建带有自定义特性参数的类型。

具体实现步骤 #

1. 编写动态类型生成工具函数
   这个函数接收特征维度参数，生成与原MLDataRow结构一致但特性参数可变的类型：

   open System
   open System.Reflection
   open System.Reflection.Emit
   open System.Collections.Generic
   open Microsoft.ML.Data
   
   // 缓存已生成的类型，避免重复创建提升性能
   let private typeCache = Dictionary<int, Type>()
   
   let createMLDataRowType (featureCount: int) =
       lock typeCache (fun () ->
           match typeCache.TryGetValue featureCount with
           | true, t -> t
           | false, _ ->
               // 定义动态程序集与模块
               let assemblyName = AssemblyName($"DynamicMLDataRow_{featureCount}")
               let assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run)
               let moduleBuilder = assemblyBuilder.DefineDynamicModule(assemblyName.Name)
   
               // 定义类型并添加CLIMutable特性
               let typeBuilder = moduleBuilder.DefineType($"MLDataRow_{featureCount}", TypeAttributes.Public ||| TypeAttributes.Class ||| TypeAttributes.Serializable)
               typeBuilder.SetCustomAttribute(CustomAttributeBuilder(typeof<CLIMutableAttribute>, [||]))
   
               // 构建Label属性及特性
               let labelField = typeBuilder.DefineField("_label", typeof<bool>, FieldAttributes.Private)
               let labelAttrs = 
                   [|
                       CustomAttributeBuilder(typeof<ColumnNameAttribute>, [| "Label" :> obj |])
                       CustomAttributeBuilder(typeof<LoadColumnAttribute>, [| 0 :> obj |])
                   |]
               let labelProp = typeBuilder.DefineProperty("Label", PropertyAttributes.None, typeof<bool>, [||])
               labelAttrs |> Array.iter labelProp.SetCustomAttribute
               // 实现Label的get方法
               let labelGet = typeBuilder.DefineMethod("get_Label", MethodAttributes.Public ||| MethodAttributes.SpecialName ||| MethodAttributes.HideBySig, typeof<bool>, [||])
               let il = labelGet.GetILGenerator()
               il.Emit(OpCodes.Ldarg_0)
               il.Emit(OpCodes.Ldfld, labelField)
               il.Emit(OpCodes.Ret)
               labelProp.SetGetMethod(labelGet)
               // 实现Label的set方法
               let labelSet = typeBuilder.DefineMethod("set_Label", MethodAttributes.Public ||| MethodAttributes.SpecialName ||| MethodAttributes.HideBySig, typeof<Void>, [| typeof<bool> |])
               let il = labelSet.GetILGenerator()
               il.Emit(OpCodes.Ldarg_0)
               il.Emit(OpCodes.Ldarg_1)
               il.Emit(OpCodes.Stfld, labelField)
               il.Emit(OpCodes.Ret)
               labelProp.SetSetMethod(labelSet)
   
               // 构建Features属性及带参数的特性
               let featuresField = typeBuilder.DefineField("_features", typeof<float32 array>, FieldAttributes.Private)
               let featuresAttrs =
                   [|
                       CustomAttributeBuilder(typeof<ColumnNameAttribute>, [| "Features" :> obj |])
                       CustomAttributeBuilder(typeof<VectorTypeAttribute>, [| featureCount :> obj |])
                       CustomAttributeBuilder(typeof<LoadColumnAttribute>, [| 1 :> obj; featureCount :> obj |])
                   |]
               let featuresProp = typeBuilder.DefineProperty("Features", PropertyAttributes.None, typeof<float32 array>, [||])
               featuresAttrs |> Array.iter featuresProp.SetCustomAttribute
               // 实现Features的get方法
               let featuresGet = typeBuilder.DefineMethod("get_Features", MethodAttributes.Public ||| MethodAttributes.SpecialName ||| MethodAttributes.HideBySig, typeof<float32 array>, [||])
               let il = featuresGet.GetILGenerator()
               il.Emit(OpCodes.Ldarg_0)
               il.Emit(OpCodes.Ldfld, featuresField)
               il.Emit(OpCodes.Ret)
               featuresProp.SetGetMethod(featuresGet)
               // 实现Features的set方法
               let featuresSet = typeBuilder.DefineMethod("set_Features", MethodAttributes.Public ||| MethodAttributes.SpecialName ||| MethodAttributes.HideBySig, typeof<Void>, [| typeof<float32 array> |])
               let il = featuresSet.GetILGenerator()
               il.Emit(OpCodes.Ldarg_0)
               il.Emit(OpCodes.Ldarg_1)
               il.Emit(OpCodes.Stfld, featuresField)
               il.Emit(OpCodes.Ret)
               featuresProp.SetSetMethod(featuresSet)
   
               // 定义构造函数，方便实例化
               let ctor = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, [| typeof<bool>; typeof<float32 array> |])
               let il = ctor.GetILGenerator()
               il.Emit(OpCodes.Ldarg_0)
               il.Emit(OpCodes.Call, typeof<obj>.GetConstructor([||]))
               il.Emit(OpCodes.Ldarg_0)
               il.Emit(OpCodes.Ldarg_1)
               il.Emit(OpCodes.Stfld, labelField)
               il.Emit(OpCodes.Ldarg_0)
               il.Emit(OpCodes.Ldarg_2)
               il.Emit(OpCodes.Stfld, featuresField)
               il.Emit(OpCodes.Ret)
   
               // 完成类型生成并缓存
               let newType = typeBuilder.CreateType()
               typeCache.Add(featureCount, newType)
               newType)
   

2. 封装实例化方法
   把类型生成和实例创建封装成易用的函数，模拟原Build方法的调用方式：

   let buildMLDataRow (featureCount: int) (label: bool) (features: float32 array) =
       let rowType = createMLDataRowType featureCount
       Activator.CreateInstance(rowType, [| label :> obj; features :> obj |])
   
   // 使用示例
   let myData = Array.init 10 (fun _ -> 0.0f)
   let a = buildMLDataRow 10 true myData
   

3. 关键注意点

   • 动态生成的类型仅在当前AppDomain有效，若需序列化需额外处理类型解析逻辑
   • 缓存机制能避免重复生成相同维度的类型，大幅提升多次调用的性能
   • 若需要强类型支持，可以结合F#的静态类型推断或使用接口约束动态类型

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