Marshaling an array of structs with `char` array fields in F#

As mentioned in the comments the following should work to declare the struct from C#:

[StructLayout(LayoutKind.Sequential)]
public unsafe struct CS_AUDIODEVICE
{
    public fixed byte device_name[64];
    public fixed byte device_id[64];
    public fixed byte rt_module[64];
    public int max_nchnls;
    public int isOutput;
}

Unfortunately, F# doesn't support the fixed syntax for declaring inline buffers. Instead, we can do:

#nowarn "9"
#nowarn "51"

open System
open System.Runtime.InteropServices
open System.Runtime.CompilerServices
open Microsoft.FSharp.NativeInterop
        
type CSOUND = struct end

[<Struct; StructLayout(LayoutKind.Sequential, Size = 64)>]
type Byte64 =
    val mutable first: byte

[<Struct; StructLayout(LayoutKind.Sequential)>]
type CS_AUDIODEVICE =
    [<FixedBuffer(typeof<byte>, 64)>]
    val mutable device_name: Byte64
    [<FixedBuffer(typeof<byte>, 64)>]
    val mutable device_id: Byte64
    [<FixedBuffer(typeof<byte>, 64)>]
    val mutable rt_module: Byte64
    val mutable max_nchnls: int
    val mutable isOutput: int

[<DllImport("csoundDLLPath", CallingConvention = CallingConvention.Cdecl)>]
extern int csoundGetAudioDevList(CSOUND* csound, CS_AUDIODEVICE* devices, int isOutput)

let writeExample () =
    let mutable x = CS_AUDIODEVICE()
    let addr = &&x.device_name.first
    let span = Span<byte>(NativePtr.toVoidPtr addr, 64)
    span[0] <- byte 'a'
    span[1] <- byte 'b'
    span[2] <- 0uy

    printfn "%s" (Marshal.PtrToStringAnsi (NativePtr.toNativeInt addr))

    
let callExample () =
    let xs = GC.AllocateArray<CS_AUDIODEVICE>(3, pinned = true) // Array must be pinned at allocation or with a GCHandle
    let mutable csound = CSOUND()
    let code = csoundGetAudioDevList(&&csound, &&xs[0], 0)
    code

We have to coerce the field addresses into a VoidPtr then we can use Span as a way to access the reserved bytes. Allocating a pinned array allows us to pass in the address to the native function.

Attempting to do this without first pinning the memory will likely crash or corrupt the program. Structs allocated with let mutable will live on the stack and it is safe to take their address while they are in scope.

Edit (Additional Explanation):

FixedBuffer isn't necessary but is emitted by the C# version (as seen when decompiling with SharpLab). I didn't test it but it should allow C# consumers to treat Byte64 as a byte[].

MarshalAs attributes cause the compiler to generate extra marshaling code behind the scenes to convert the .NET type into a native compatible type. The way it is done with Byte64 the struct is unmanaged ref1 ref2 and no additional marshaling code is needed.

Span isn't strictly necessary and you can freely convert between IntPtr and nativeptr<_> using the NativePtr module functions. This module gives you ways to do pointer manipulation directly. IntPtr.Zero is equivalent to NativePtr.nullPtr and nativeptr<_> gets erased to IntPtr by the F# compiler.

It turns out that one of the main issues in figuring all of this out properly is that the Csound API documentation is out of date. If we view the CS_AUDIODEVICE struct in the API documentation, then we see that the char arrays are of length 64. However, if we navigate to the Csound repository, the header lists the arrays in CS_AUDIODEVICE as length 128. This is unfortunate, since it means I and others here were spinning wheels on something that couldn't possibly work due to the documentation error.

Thankfully, due to @tranquillity's answer, I was able to get some actual data back with their method (instead of just crashes) and noticed that the data was incomplete. I then looked up the Python Csound API bindings, which happen to be in the Csound repository itself, which is where I saw the 128 length and then confirmed it in the csound.h header file.

Since there are a lot of the structures like this in the Csound API, I am wanting something a bit more straightforward, so I played around a bit and come up with:

open System
open System.Runtime.InteropServices

[<Struct>]
type CSOUND = struct end

[<Struct; StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)>]
type CS_AUDIODEVICE =
    [<MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)>]
    val device_name: string // char[128]
    [<MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)>]
    val device_id:   string // char[128]
    [<MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)>]
    val rt_module:   string // char[128]
    val max_nchnls:  int
    val isOutput:    int

[<DllImport(csoundDLLPath, CallingConvention = CallingConvention.Cdecl)>]
extern int csoundGetAudioDevList(CSOUND* csound, IntPtr devices, int isOutput)

let marshalIntPtrToStructures<'Structure> (pointer: IntPtr, numberOfStructures) =
    let mutable pointer = pointer
    [| for _ in 1..numberOfStructures ->
        let structure = Marshal.PtrToStructure<'Structure>(pointer)
        pointer <- IntPtr.Add(pointer, Marshal.SizeOf<'Structure>())
        structure |]

let initializeIntPtrFromStructures<'Structure> numberOfStructures: IntPtr =
    Marshal.AllocHGlobal(numberOfStructures * Marshal.SizeOf<CS_AUDIODEVICE>())

let getAudioDeviceOutputs (Csound csound) =
    printfn "Size of CS_AUDIODEVICE: %A" (Marshal.SizeOf<CS_AUDIODEVICE>())

    let numberOfDevices = csoundGetAudioDevList(csound, IntPtr.Zero, 1)

    printfn "Number of devices: %A" numberOfDevices
    
    let pointer = initializeIntPtrFromStructures<CS_AUDIODEVICE> numberOfDevices

    csoundGetAudioDevList(csound, pointer, 1) |> ignore

    let devices =  marshalIntPtrToStructures<CS_AUDIODEVICE>(pointer, numberOfDevices)

    for device in devices do
        printfn "Name: %A, ID: %A" device.device_name device.device_id

The printfn statements are there to confirm the values are what I expect. This all works now! And this should be generally reusable across the several structs in the Csound API (I hope). It also allows me to define the struct in a more straightforward way and makes it easier to marshal out the fields once I have the array of structs in hand.

What I am still curious about though is if there is a better and/or built-in way to do what the marshalIntPtrToStructures and initializeIntPtrFromStructures are doing. It seems kind of strange that there isn't, at least I couldn't find them, especially for marshalIntPtrToStructures. From what I have seen, you cannot use the built-in Marshal.PtrToStructure on an array. I was getting unsupported type exceptions like: System.MissingMethodException: Cannot dynamically create an instance of type 'FSI_0028.Csound.Native+CS_AUDIODEVICE[]'. Reason: Type is not supported. (I think that is the right exception from when I tried that).

A final note. Microsoft has documentation for marshaling arrays and structs here:

• https://learn.microsoft.com/en-us/dotnet/framework/interop/marshalling-classes-structures-and-unions#structures-sample

• https://learn.microsoft.com/en-us/dotnet/framework/interop/marshalling-different-types-of-arrays

The problem with those methods is that the csoundGetAudioDevList is a bit weird and requires a null pointer to be passed in to first get the number of audio devices. Then you call it again with a properly constructed pointer to get the actual devices. With the methods described in the two bullets above, there is no way to pass in a null pointer with the way that the prototypes are declared, as far as I can tell. Those methods are the easiest since they defer a lot of the marshaling (to the CLR, I guess), but they don't work for an unmanaged function like csoundGetAudioDevList that also requires use of a null pointer.