如何从我的应用程序向/从 DLL 传递和检索内存流？

Question

假设我有一个TMemoryStream，我需要传递给我的 DLL 并从 DLL 中取回 TMemoryStream（位图流）。

我在想我的 DLL 会有：

procedure Process(
  InBuff: Pointer; 
  InBuffSize: Integer; 
  var OutBuff: Pointer; 
  var OutBuffSize: Integer
); stdcall;

InBuff 很简单（我认为）。我通过TMemoryStream.Memory 和TMemoryStream.Size。

问题是我如何在 DLL 中分配OutBuff，调用者应用程序可以将其转换回TMemoryStream，然后释放该内存（由调用者应用程序）？

调用者将使用动态LoadLibrary/FreeLibrary每个DLL调用。

我非常想要一个示例代码。希望我不会太粗鲁。

注意 1：调用者应用程序不知道输出大小，并假设它不能指定 MAX buff 大小。

注意 2：我不确定我的 DLL 签名。如果我做错了，请原谅我。我正在寻找一种可以很好地工作的模式（可能不仅适用于 Delphi，而且适用于 C++/C# Caller = 我的奖励）

Answer 1

一种稍微不同的方法是将每个内存流包装为 IStream，并传递生成的接口引用。所以，从 DLL 的角度来看：

uses
  System.SysUtils, System.Classes, Vcl.AxCtrls;

procedure DoProcess(InStream, OutStream: TStream);
begin
  //...do the actual processing here
end;

//wrapper export
procedure Process(AInStream: IStream; out AOutStream: IStream); safecall;
var
  InStream, OutStream: TStream;
begin
  InStream := TOleStream.Create(AInStream);
  try
    OutStream := TMemoryStream.Create;
    try
      DoProcess(InStream, OutStream);
      AOutStream := TStreamAdapter.Create(OutStream, soOwned);
    except
      OutStream.Free;
      raise;
    end;
  finally
    InStream.Free;
  end;
end;

我个人也喜欢使用 safecall，因为它是一种简单的异常安全方法，但我想这是一个品味问题。

编辑

上面的一个变体是让调用者同时提供要读取的流和要写入的流：

//wrapper export
procedure Process(AInStream, AOutStream: IStream); safecall;
var
  InStream, OutStream: TStream;
begin
  InStream := TOleStream.Create(AInStream);
  try
    OutStream := TOleStream.Create(AOutStream);
    try
      DoProcess(InStream, OutStream);
    finally
      OutStream.Free;
    end;
  finally
    InStream.Free;
  end;
end;

EXE 端可能看起来像这样：

//wrapper import
type
  TDLLProcessProc = procedure(AInStream, AOutStream: IStream); safecall;

procedure Process(AInStream, AOutStream: TStream);
var
  InStream, OutStream: IStream;
  DLLProc: TDLLProcessProc;
  Module: HMODULE;
begin
  InStream := TStreamAdapter.Create(AInStream, soReference);
  OutStream := TStreamAdapter.Create(AOutStream, soReference);
  Module := LoadLibrary(MySuperLib);
  if Module = 0 then RaiseLastOSError;
  try
    DLLProc := GetProcAddress(Module, 'Process');
    if @DLLProc = nil then RaiseLastOSError;
    DLLProc(InStream, OutStream);
  finally
    FreeLibrary(Module);
  end;
end;

Answer 2

两个明显的选择，假设被调用者是分配内存：

1.使用共享堆

例如，您可以使用 COM 堆。在被调用者中你写：

OutBuffSize := ...; // you know what this value is
OutBuff := CoTaskMemAlloc(OutBuffSize);
// populate the buffer

调用者用CoTaskMemFree 销毁它。如果您愿意，可以使用LocalAlloc 或HeapAlloc，这并不重要。

2。使用被调用者的堆并导出一个释放器

这里你使用被调用者的原生堆：

OutBuffSize := ...; // you know what this value is
GetMem(OutBuff, OutBuffSize);
// populate the buffer

你还需要导出一个释放器：

procedure DeallocateMemory(Ptr: Pointer); stdcall;
begin
  FreeMem(Ptr);
end;

---

我拒绝的另一个选择是使用共享内存管理器。我倾向于避免这种情况，因为它将调用者限制为 Delphi 程序。

从缓冲区调用 WriteBuffer 填充流：

Stream.WriteBuffer(Buff^, BuffSize);

其中Buff 是指向缓冲区的指针。

Answer 3

InBuff 很简单（我认为）。我通过了 TMemoryStream.Memory 和 TMemoryStream.Size。

是的。

问题是我如何在 DLL 中分配 OutBuff，调用者应用程序可以将其转换回 TMemoryStream 并随后释放该内存（由调用者应用程序）？

鉴于您展示的 DLL 函数的签名，您根本不会在 DLL 中分配内存。调用者必须分配它。调用者可以调用Process() 一次以获得所需的大小，然后分配它，然后再次调用Process() 来填充它。这样，调用者负责分配和释放内存。例如：

procedure Process(InBuff: Pointer; InBuffSize: Integer; OutBuff: Pointer; var OutBuffSize: Integer); stdcall;
begin
  //...
  if (OutBuf <> nil) then
  begin
    // copy no more than OutBuffSize bytes into OutBuf, and then
    // update OutBuffSize with the number of bytes actually copied...
    Move(..., OutBuf^, ...);
    OutBuffSize := ...;
  end else begin
    // update OutBuffSize with the number of bytes needed for OutBuff...
    OutBuffSize := ...;
  end;
  //...
end;

var
  InStream: TMemoryStream;
  OutStream: TMemoryStream;
  BuffSize: Integer;
begin
  InStream := TMemoryStream.Create;
  try
    // fill InStream as needed...

    BuffSize := 0;
    Process(InStream.Memory, InStream.Size, nil, BuffSize);

    OutStream := TMemoryStream.Create;
    try
      OutStream.Size := BuffSize;
      Process(InStream.Memory, InStream.Size, OutStream.Memory, BuffSize);
      // use OutStream as needed...
    finally
      OutStream.Free;
    end;
  finally
    InStream.Free;
  end;
end;

如果您确实希望 DLL 分配内存，则必须更改 DLL 函数的签名以使 OutBuff 成为 var 参数。您还必须导出一个附加函数，以便 DLL 可以释放 DLL 分配的内存。这种方法的好处是调用者只需调用Process() 一次，DLL 可以决定它要如何分配和释放内存。例如：

procedure Process(InBuff: Pointer; InBuffSize: Integer; var OutBuff: Pointer; var OutBuffSize: Integer); stdcall;
begin
  //...
  OutBuffSize := ...;
  GetMem(OutBuf, OutBuffSize);
  Move(..., OutBuf^, OutBuffSize);
  //...
end;

procedure FreeProcessBuff(InBuff: Pointer); stdcall;
begin
  FreeMem(InBuff);
end;

type
  TMemoryBufferStream = class(TCustomMemoryStream)
  public
    constructor Create(APtr: Pointer; ASize: NativeInt);
  end;

procedure TMemoryBufferStream.Create(APtr: Pointer; ASize: NativeInt);
begin
  inherited Create;
  SetPointer(APtr, ASize);
end;

...

var
  InStream: TMemoryStream;
  OutStream: TMemoryBufferStream;
  Buff: Pointer;
  BuffSize: Integer;
begin
  InStream := TMemoryStream.Create;
  try
    // fill InStream as needed...

    Buff := nil;
    BuffSize := 0;
    Process(InStream.Memory, InStream.Size, Buff, BuffSize);
    try
      OutStream := TMemoryBufferStream.Create(Buff, BuffSize);
      try
        // use OutStream as needed...
      finally
        OutStream.Free;
      end;
    finally
      FreeProcessBuff(Buff);
    end;
  finally
    InStream.Free;
  end;
end;