Възможно ли е подравняване 1:1 на C# структури с поточно предавани записи на Delphi?

Подравняването обикновено се използва от компилатора като оптимизация. Всъщност всяка структура е подплатена до кратно на 4 (или 8, не помня точно).

Актуализация: Това, което казвам по-горе относно подравняването, не е точно. Прочетете отговора на Дейвид за подробности относно това как подравнените записи се третират от компилатора. Статията в Wikipedia съдържа разумен преглед: http://en.wikipedia.org/wiki/Data_structure_alignment

Както и да е, можете да използвате параметъра Pack, за да укажете подравняването. Стойност на Pack от 1 връща точния размер на структурата.

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]

Относно масивите, правилно е да използвате:

[MarshalAs(UnmanagedType.ByValArray, SizeConst = 20)]
public char[] someCharArray;

Просто внимавайте, когато преобразувате от структура в байтов масив, че масивът трябва да съответства на декларирания размер. Преди конвертиране трябва да използвате Array.Resize, ако съдържанието е по-кратко.

struct.someCharArray = "Hello".ToCharArray();
Array.Resize<char>(ref struct.someCharArray, 20);

За маршалинга използвам този метод от байт [] до структура:

    public static T ParseStructure<T>(byte[] array, int offset) where T : struct
    {
        if (array == null) throw new ArgumentNullException("array", "Input parameter cannot be null");

        if (array.Length - offset < Marshal.SizeOf(typeof(T)))
            Array.Resize<byte>(ref array, Marshal.SizeOf(typeof(T)) + offset);

        int arraySize = array.Length - offset;
        T returnItem;

        // Allocate some unmanaged memory.
        IntPtr buffer = Marshal.AllocHGlobal(arraySize);

        // Copy the read byte array (byte[]) into the unmanaged memory block.
        Marshal.Copy(array, offset, buffer, arraySize);

        // Marshal the unmanaged memory block to a structure.
        returnItem = (T)Marshal.PtrToStructure(buffer, typeof(T));

        // Free the unmanaged memory block.
        Marshal.FreeHGlobal(buffer);

        return returnItem;
 }

И този метод прави обратното:

    public static byte[] StructureToArray<T>(T structure) where T : struct
    {
        int objectSize = Marshal.SizeOf(structure);
        byte[] result = new byte[objectSize];
        IntPtr buffer = Marshal.AllocHGlobal(objectSize);

        object dataStructure = (object)structure;

        Marshal.StructureToPtr(dataStructure, buffer, true);

        Marshal.Copy(buffer, result, 0, objectSize);
        Marshal.FreeHGlobal(buffer);
        return result;
    }

Също така, моля, използвайте следния код, за да проверите размера, изчислен от рамката:

int objectSize = Marshal.SizeOf(structure);

Най-накрая намерих тази хубава статия за маршалинга.

Ще предположа, че вашият Delphi компилатор работи в режим по подразбиране, както и подравняването на записите. Предполагам също, че вашият Pascal код съдържа проста печатна грешка, където вашият масив има 5 елемента вместо 4.

Подравняването на подравнен запис се определя от члена с най-голямо подравняване. Най-големият член е 8-байтовото двойно. Така че записът има подравняване 8. Размерът му е точно кратно на подравняването му.

Всяко отделно поле е подравнено, за да съответства на подравняването на полето. Масивът от байтове има подравняване 1 и може да се появи навсякъде. 2-байтовите цели числа трябва да се появяват на 2-байтови граници и т.н. Записите може да имат подложка в края, за да се гарантира, че масивите от записа също ще бъдат подравнени. Така записът има размер, кратен на 8. Вашият запис има размер 24.

Във вашия случай подпълването е преди 8-байтовото двойно и в края на записа. Ако тази подложка в края не беше включена, 8-байтовото двойно ще бъде неправилно подравнено във всички масиви на вашия запис.

Няма нужда да правите каквито и да е промени във вашия запис на Delphi и декларациите на C# структура. Те вече са декларирани правилно и съвпадат перфектно.

Можете да използвате SizeOf в Delphi и Marshal.SizeOf в C#, за да проверите размера на вашите структури. Ще откриете, че съвпадат с кода във въпроса.

Не мога да коментирам как вашият код се е провалил, защото не сте описали тази повреда. Моята основна гледна точка е, че всеки провал не се дължи на несъответствие между вашите структури. Няма рационално обяснение за източника на числото 22. Бих потърсил откъде идва това число.

И накрая, отговорът, който приехте, предлага използването на пакетирани структури. Няма нужда да го правите, не виждам причина да го правите и това не обяснява вашите проблеми.