为什么 C++ 从 C# 获取错误的参数值，因为 function 返回自定义结构

Question

Suppose I have the following C# Console application calling a C++ library.

internal static class Program
{
    private struct NumberContainer
    {
        internal int Number1 { get; }
        internal uint Number2 { get; }

        internal NumberContainer(int number1, uint number2)
        {
            Number1 = number1;
            Number2 = number2;
        }

        public override string ToString()
            => $"{Number1}, {Number2}";
    }

    [DllImport("CPlusPlusTargetLibrary.dll", CallingConvention = CallingConvention.Cdecl)]
    private static extern int Add(int number1, uint number2);

    [DllImport("CPlusPlusTargetLibrary.dll", CallingConvention = CallingConvention.Cdecl)]
    private static extern NumberContainer Compose(int signedInput, uint unsignedInput);

    private static void Main(string[] args)
    {
        var unsignedInput = args.Any() && uint.TryParse(args.First(), out uint unsignedValue) ? unsignedValue : 0;
        var signedInput = args.Count() > 1 && int.TryParse(args.ElementAt(1), out int signedValue) ? signedValue : 0;

        Console.WriteLine("Adding {0} and {1}...", signedInput, unsignedInput);
        Console.WriteLine("Result = {0}", Add(signedInput, unsignedInput));

        Console.WriteLine("Composing {0} and {1}...", signedInput, unsignedInput);
        Console.WriteLine("Composed {0}", Compose(signedInput, unsignedInput));
    }
}

And the following header file in CPlusPlusTargetLibrary.dll :

#pragma once

struct NumberContainer
{
    const signed long Number1;
    const unsigned long Number2;

    NumberContainer(const signed long number1, const unsigned long number2)
        : Number1(number1),
        Number2(number2)
    {
    }
};

extern "C" __declspec(dllexport) signed long __cdecl Add
(
    signed long number1,
    unsigned long number2
);

extern "C" __declspec(dllexport) NumberContainer __cdecl Compose
(
    signed long signedInput,
    unsigned long unsignedInput
);

And the following corresponding CPP file for that header:

#include "pch.h"
#include "TargetFunctions.h"

extern "C"
{    
    __declspec(dllexport) signed long __cdecl Add(signed long number1, unsigned long number2)
    {
        return number1 + number2;
    }

    __declspec(dllexport) NumberContainer __cdecl Compose(signed long number1, unsigned long number2)
    {
        return NumberContainer
        (
            number1,
            number2
        );
    }
}

Given 5 as the unsignedInput in C# and -8 as the signedInput , why is it that Add correctly receives -8 and 5 when the breakpoint on the return statement in its C++ implementation is hit, but Compose receives 5 and 710724189 ?

Also, as a side, the immutable struct NumberContainer fails to initialize throwing a write access violation. exception once Number1(number1) is hit - albeit this is after the faulty values have been received so this probably isn't relevant to the 1st problem I'm trying to resolve.

If I flip the call order, Compose then receives 5 and 1817521252 but I cannot proceed any further to see what Add receives due to the aforementioned exception.

From debugging, I have found that placing a breakpoint on the opening curly brace of either implementation shows incorrect parameter values; after this line, the parameter values are both correct for Add but for Compose the 1st parameter is consistently correct if it were the 2nd parameter whilst the 2nd parameter appears to be some random value in memory. I'm thinking something's offset the arguments so that the first one is being discarded somewhere between the C# and C++ but what is doing that, I am not sure (I've also tried using __stdcall with CallingConvention.StdCall and CallingConvention.Winapi both to the same end result).

Answer 1

With the help of this article I found the answer: https://www.codeproject.com/Articles/66243/Marshaling-with-C-Chapter-3-Marshaling-Compound-Ty

All I had to do was mark my C# NumberContainer struct with the StructLayoutAttribute like this, and the parameter values started coming in correctly!

[StructLayout(LayoutKind.Sequential, Size = 64)]
private struct NumberContainer
{
    internal int Number1 { get; }
    internal uint Number2 { get; }

    internal NumberContainer(int number1, uint number2)
    {
        Number1 = number1;
        Number2 = number2;
    }

    public override string ToString()
        => $"{Number1}, {Number2}";
}

I believe what was happening before was the struct was being assumed to be 32-bit by C++ and thus the first parameter of -8 (a 32-bit signed integer) was making up the 2nd half of the default 64-bit NumberContainer struct on the C++ side. However, having said this: if I change Size to 32 or 128 and do a rebuild, it weirdly continues to pass the correct parameter values in! If Size is omitted from the attribute though, then the parameter values come in incorrectly as before.

I seem to have resolved the original problem and the immutable struct successfully instantiates and returns from the C++ code, but the aforementioned mystery about the Size parameter is still unsolved. If someone has an answer to this then I'll happily accept it over my own.