Why does returning a custom struct from an UnmanagedCallersOnly method cause a __cdecl syntax error?

Below is what’s happening:

• Although your method signature compiles in C#, the use of [UnmanagedCallersOnly] forces the method’s parameters and return value to be “unmanaged” (i.e. blittable). In your example the string‐returning method works because you’re returning an IntPtr (a pointer). When you return your custom struct, even though it only contains an int and an IntPtr, DNNE’s native wrapper generator stumbles when emitting the appropriate signature. This shows up as a syntax error (in this case, on the __cdecl specifier) in the generated native C code.

• In short, DNNE (and the CLR’s UnmanagedCallersOnly support) currently does not support returning user‐defined structs by value from an UnmanagedCallersOnly method. (Even if your struct is unmanaged, the wrapper generation and calling convention handling do not yet support it.)

The recommended workarounds are:

1. Change the API so that instead of returning your struct by value you return a pointer (e.g. allocate the struct on the unmanaged heap and return its address). For example:

CSHARPCopied
using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential)]
public struct ReturnTest
{
    public int code;
    public IntPtr txt;
}

public unsafe class Exports
{
    [UnmanagedCallersOnly]
    public static ReturnTest* TestFunction()
    {
        // Allocate unmanaged memory for the structure.
        ReturnTest* ret = (ReturnTest*)Marshal.AllocHGlobal(sizeof(ReturnTest));
        ret->code = 1337;
        ret->txt = Marshal.StringToBSTR("a b c d q ¥ K xyz");
        return ret;
    }
}

2. Alternatively, redesign your API so that the caller passes in a pointer (or use an out parameter) for the struct that your method fills in.

Either approach avoids returning a struct by value and prevents DNNE’s native code generator from emitting problematic signatures.

Remember that even when using UnmanagedCallersOnly, you must design your exported API using only unmanaged types in the exposed signature.