当 TRttiProperty.SetValue 与 TMemoryStream 属性一起使用时，如何避免内存泄漏？

如何解决当 TRttiProperty.SetValue 与 TMemoryStream 属性一起使用时，如何避免内存泄漏？

我使用 SourceProperties[0].SetValue(lObject,lStream) 来设置 MemoryStream : TMemoryStream 的 lObject 属性。

如果我随后释放 lStream，MemoryStream 的 lObject 属性似乎设置为 nil。

如果我不释放 lStream，就会出现内存泄漏。

通过 RTTI 将 lStream 分配给 MemoryStream 属性的正确方法是什么？

下面列出的完整示例代码：

unit Unit28;

interface

uses
  System.SysUtils,System.Types,System.UITypes,System.Classes,System.Variants,FMX.Types,FMX.Controls,FMX.Forms,FMX.Graphics,FMX.Controls.Presentation,FMX.StdCtrls,System.Rtti;

type
  TMyObject = Class(TObject)
  private
    pMemoryStream : TMemoryStream;
  published
    property MemoryStream : TMemoryStream read pMemoryStream  write pMemoryStream;
    constructor Create;
    destructor  Destroy;override;
  end;

type
  TForm28 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form28: TForm28;

implementation


{$R *.fmx}

constructor TMyObject.Create;
begin
  pMemoryStream := TMemoryStream.Create;
end;

destructor TMyObject.Destroy;
begin
  pMemoryStream.DisposeOf;
  inherited;
end;


////Problematic when using RTTI
procedure TForm28.Button1Click(Sender: TObject);
var
  SourceRttiContext : TRttiContext;
  SourceRttiType : TRttiType;
  SourceProperties: TArray<TRttiProperty>;
  lStream : TMemoryStream;
  lObject : TObject;
begin
  lObject := TMyObject.Create;
  SourceRttiType := SourceRttiContext.GetType(lObject.ClassType);
  SourceProperties := SourceRttiType.GetProperties;
  lStream := TMemoryStream.Create;
  lStream.LoadFromFile('C:\Users\Public\Pictures\Sample Pictures\Desert.jpg');
  if (SourceProperties[0].PropertyType.ToString = 'TMemoryStream') then
  begin
    SourceProperties[0].SetValue(lObject,lStream);
  end;
  lStream.DisposeOf;
  TMyObject(lObject).MemoryStream.SaveToFile('C:\Users\Public\Pictures\Sample Pictures\Test1.jpg');
  lObject.DisposeOf;
end;


////No problems when not using RTTI
procedure TForm28.Button2Click(Sender: TObject);
var
  lStream : TMemoryStream;
  lObject : TMyObject;
begin
  lObject := TMyObject.Create;
  lStream := TMemoryStream.Create;
  lStream.LoadFromFile('C:\Users\Public\Pictures\Sample Pictures\Desert.jpg');
  lObject.MemoryStream.LoadFromStream(lStream);
  lStream.DisposeOf;
  lObject.MemoryStream.SaveToFile('C:\Users\Public\Pictures\Sample Pictures\Test1.jpg');
  lObject.DisposeOf;
end;

end. 

解决方法

您不仅有泄漏，而且还在处理死内存流对象。

问题在于，当您设置 MemoryStream 属性时，您直接将其引用设置为指向本地创建的 lStream 对象。您没有创建副本，因此您正在泄漏在 TMyObject 构造函数中创建的内存流实例。

我不确定在您的示例中使用 RTTI 的目的是什么，最佳解决方案取决于您要实现的目标，这并不完全清楚。

如果你需要通过 RTTI 设置流，那么你需要实现属性设置器以避免泄漏。

  TMyObject = Class(TObject)
  private
    pMemoryStream : TMemoryStream;
    procedure SetMemoryStream(const Value: TMemoryStream);
  published
    property MemoryStream: TMemoryStream read pMemoryStream write SetMemoryStream;
    constructor Create;
    destructor  Destroy; override;
  end;

procedure TMyObject.SetMemoryStream(const Value: TMemoryStream);
begin
  pMemoryStream.CopyFrom(Value,0);
end;

var
  SourceRttiContext : TRttiContext;
  SourceRttiType : TRttiType;
  SourceProperties: TArray<TRttiProperty>;
  lStream : TMemoryStream;
  lObject : TObject;
begin
  lObject := TMyObject.Create;
  try
    SourceRttiType := SourceRttiContext.GetType(lObject.ClassType);
    SourceProperties := SourceRttiType.GetProperties;
    lStream := TMemoryStream.Create;
    try
      lStream.LoadFromFile('C:\Users\Public\Pictures\Sample Pictures\Desert.jpg');
      if (SourceProperties[0].PropertyType.ToString = 'TMemoryStream') then
      begin
        SourceProperties[0].SetValue(lObject,lStream);
      end;
      TMyObject(lObject).MemoryStream.SaveToFile('C:\Users\Public\Pictures\Sample Pictures\Test1.jpg');
    finally
      lStream.Free;
    end;
  finally
    lObject.Free;
  end;
end;

但是，创建副本会占用更多内存。为避免这种情况，解决方案之一是将本地创建的流的所有权转移到 TMyObject。在这种情况下，您不应在本地释放 lStream。由于所有权转移使异常处理复杂化，因此处理双重释放的最简单方法是在转移完成后将 lStream 设置为 nil，TMyObject 实例将负责释放内存流。

procedure TMyObject.SetMemoryStream(const Value: TMemoryStream);
begin
  pMemoryStream.Free;
  pMemoryStream := Value;
end;

var
  SourceRttiContext : TRttiContext;
  SourceRttiType : TRttiType;
  SourceProperties: TArray<TRttiProperty>;
  lStream : TMemoryStream;
  lObject : TObject;
begin
  lObject := TMyObject.Create;
  try
    SourceRttiType := SourceRttiContext.GetType(lObject.ClassType);
    SourceProperties := SourceRttiType.GetProperties;
    lStream := TMemoryStream.Create;
    try
      lStream.LoadFromFile('C:\Users\Public\Pictures\Sample Pictures\Desert.jpg');
      if (SourceProperties[0].PropertyType.ToString = 'TMemoryStream') then
        begin
          SourceProperties[0].SetValue(lObject,lStream);
          // ownership transfer is successful nil local reference to
          // avoid double free
          lStream := nil;
        end;
      TMyObject(lObject).MemoryStream.SaveToFile('C:\Users\Public\Pictures\Sample Pictures\Test1.jpg');
    finally
      lStream.Free;
    end;
  finally
    lObject.Free;
  end;
end;

但这里的主要问题仍然是为什么您首先使用本地创建的内存流，而不是直接使用 TMyObject 内存流实例加载图像？

,

使用 RTTI 时，您将属性 MemoryStream 更改为指向先前从文件加载的新创建的本地内存流。

不使用 RTTI 时，获取属性内存流并调用 LoadFromStream 将其与本地流一起加载。

这两种方法明显不同！

有几种方法可以解决这个问题。

一个是改变你使用 RTTI 的方式：而不是 SetValue，使用 GetValue 来获取内存流的实例，就像你不使用 RTTI 一样，然后调用 LoadFromStream。

另一个是为 MemoryStream 属性添加一个 setter。调用时，它使用 LoadFromStream 加载“内部”内存流。