Передача двумерных массивов с типом double между C# и Delphi через DLL

Delphi , Файловая система , DLL и PlugIns

При разработке программного обеспечения часто возникает необходимость обмена данными между компонентами, написанными на разных языках программирования. В данном случае рассматривается задача передачи двумерных массивов с типом double между приложением на C# и библиотекой, написанной на Delphi, через динамически подключаемую библиотеку (DLL).

Описание проблемы

Разработчик C# приложения столкнулся с задачей вызова функций из DLL, написанной на Delphi. Ему необходимо передать двумерный массив из C# в DLL, после чего DLL должна создать другой массив и вернуть его обратно в C# код.

Решение

Для решения этой задачи можно использовать P/Invoke (Platform Invocation Services) – функциональность .NET, позволяющую вызывать функции из неуправляемого кода (неуправляемых DLL) из управляемого кода (C#).

Пример кода на Object Pascal (Delphi)

library mydll;
{$R *.res}

uses
  SysUtils;

type
  PDouble = ^Double;
  TDoubleArray = array of PDouble;

var
  arr: TArrayOfDoubleArrays;

procedure ManagedToNative(RowCount, ColCount: Integer; Values: PDouble); stdcall;
var
  r, c: Integer;
begin
  SetLength(arr, RowCount, ColCount);
  for r := 0 to RowCount-1 do begin
    for c := 0 to ColCount-1 do begin
      arr[r, c] := Values^;
      Inc(Values);
    end;
  end;
end;

procedure NativeToManaged(var RowCount, ColCount: Integer; var Values: TDoubleArray): stdcall;
var
  r, c: Integer;
begin
  RowCount := Length(arr);
  if RowCount > 0 then
    ColCount := Length(arr[0])
  else
    ColCount := 0;

  SetLength(Values, RowCount * ColCount);
  if RowCount > 0 then begin
    for r := 0 to RowCount-1 do begin
      for c := 0 to ColCount-1 do begin
        Values^[r * ColCount + c] := arr[r, c];
      end;
    end;
  end;
end;

exports
  ManagedToNative,
  NativeToManaged;

begin
end.

Пример кода на C

using System;
using System.Runtime.InteropServices;

class Program
{
    [DllImport("mydll.dll", CallingConvention = CallingConvention.StdCall)]
    private static extern void ManagedToNative(int RowCount, int ColCount, double[] Values);

    [DllImport("mydll.dll", CallingConvention = CallingConvention.StdCall)]
    private static extern void NativeToManaged(out int RowCount, out int ColCount, out double[] Values);

    static double[] Flatten(double[,] array)
    {
        int length = array.GetLength(0) * array.GetLength(1);
        double[] flat = new double[length];
        int index = 0;
        for (int i = 0; i < array.GetLength(0); i++)
            for (int j = 0; j < array.GetLength(1); j++)
                flat[index++] = array[i, j];
        return flat;
    }

    static double[,] Unflatten(double[] flat, int rows, int cols)
    {
        double[,] array = new double[rows, cols];
        int index = 0;
        for (int i = 0; i < rows; i++)
            for (int j = 0; j < cols; j++)
                array[i, j] = flat[index++];
        return array;
    }

    static void Main()
    {
        double[,] array = new double[,] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
        ManagedToNative(array.GetLength(0), array.GetLength(1), Flatten(array));

        int rowCount, colCount;
        NativeToManaged(out rowCount, out colCount, null);
        double[] flattened = new double[rowCount * colCount];
        NativeToManaged(out rowCount, out colCount, flattened);
        double[,] result = Unflatten(flattened, rowCount, colCount);

        for (int i = 0; i < rowCount; i++)
        {
            for (int j = 0; j < colCount; j++)
                Console.Write("{0,3}", result[i, j]);
            Console.WriteLine();
        }
    }
}

В данном примере используется техника "плоского" представления двумерного массива (flattening), то есть двумерный массив представляется как одномерный массив для удобства передачи между C# и Delphi. Это не самый эффективный способ, но он достаточно прост в реализации и может быть достаточен для большинства задач.

Заключение

Передача двумерных массивов между C# и Delphi через DLL возможна и может быть реализована с использованием P/Invoke. Важно правильно структурировать данные и использовать соответствующие типы данных в каждом из языков программирования.

Создано по материалам из источника по ссылке.

Передача двумерных массивов с типом `double` между C# и Delphi через DLL требует использования специальных методов и техник, таких как 'плоское' представление массива, для обеспечения совместимости между языками.

Комментарии и вопросы

Получайте свежие новости и обновления по Object Pascal, Delphi и Lazarus прямо в свой смартфон. Подпишитесь на наш Telegram-канал delphi_kansoftware и будьте в курсе последних тенденций в разработке под Linux, Windows, Android и iOS

:: Главная :: DLL и PlugIns ::