delphi - puede - metodos anonimos c#

Interfaces, métodos anónimos y fugas de memoria

Question

Este es un ejemplo construido. No quiero publicar el código original aquí. Aunque traté de extraer las partes relevantes.

Tengo una interfaz que gestiona una lista de oyentes.

TListenerProc = reference to procedure (SomeInt : ISomeInterface);

ISomeInterface = interface
   procedure AddListener (Proc : TListenerProc);   
end;

Ahora registro a un oyente:

SomeObj.AddListener (MyListener);

procedure MyListener (SomeInt : ISomeInterface);
begin
  ExecuteSynchronized (procedure
                       begin
                       DoSomething (SomeInt);
                       end);
end;

Tengo fugas de memoria. Tanto el método anónimo como las interfaces nunca se liberan. Sospecho que esto se debe a algún tipo de referencia circular aquí. El método anónimo mantiene la interfaz alife y la interfaz mantiene el método anónimo alife.

Dos preguntas:

1. ¿Apoyas esa explicación? ¿O me estoy perdiendo algo más aquí?
2. ¿Hay algo que pueda hacer al respecto?

¡Gracias por adelantado!

EDITAR : No es tan fácil reproducir esto en una aplicación lo suficientemente pequeña como para publicarlo aquí. Lo mejor que puedo hacer ahora es lo siguiente. El método anónimo no se libera aquí:

program TestMemLeak;

{$APPTYPE CONSOLE}

uses
  Generics.Collections, SysUtils;

type
  ISomeInterface = interface;
  TListenerProc  = reference to procedure (SomeInt : ISomeInterface);

  ISomeInterface = interface
  [''{DB5A336B-3F79-4059-8933-27699203D1B6}'']
    procedure AddListener (Proc : TListenerProc);
    procedure NotifyListeners;
    procedure Test;
  end;

  TSomeInterface = class (TInterfacedObject, ISomeInterface)
  strict private
    FListeners          : TList <TListenerProc>;
  protected
    procedure AddListener (Proc : TListenerProc);
    procedure NotifyListeners;
    procedure Test;
  public
    constructor Create;
    destructor  Destroy; override;
  end;


procedure TSomeInterface.AddListener(Proc: TListenerProc);
begin
FListeners.Add (Proc);
end;

constructor TSomeInterface.Create;
begin
FListeners := TList <TListenerProc>.Create;
end;

destructor TSomeInterface.Destroy;
begin
FreeAndNil (FListeners);
  inherited;
end;

procedure TSomeInterface.NotifyListeners;

var
  Listener : TListenerProc;

begin
for Listener in FListeners do
  Listener (Self);
end;

procedure TSomeInterface.Test;
begin
// do nothing
end;

procedure Execute (Proc : TProc);

begin
Proc;
end;

procedure MyListener (SomeInt : ISomeInterface);
begin
Execute (procedure
         begin
         SomeInt.Test;
         end);
end;

var
  Obj     : ISomeInterface;

begin
  try
    ReportMemoryLeaksOnShutdown := True;
    Obj := TSomeInterface.Create;
    Obj.AddListener (MyListener);
    Obj.NotifyListeners;
    Obj := nil;
  except
    on E: Exception do
      Writeln(E.ClassName, '': '', E.Message);
  end;
end.

Answer 1

El problema es con los métodos anónimos en la página principal de dpr.

Simplemente ponga su código en una rutina y llámelo al dpr main y el informe de pérdida de memoria se habrá ido.

procedure Main;
var
  Obj: ISomeInterface;
begin
  try
    ReportMemoryLeaksOnShutdown := True;
    Obj := TSomeInterface.Create;
    Obj.AddListener (MyListener);
    Obj.NotifyListeners;
    Obj := nil;
  except
    on E: Exception do
      Writeln(E.ClassName, '': '', E.Message);
  end;
end;

begin
  Main;
end.

Answer 2

Me parece un tema de referencia circular definido. Los métodos anónimos se administran a través de interfaces ocultas, y si TList<TListenerProc> es propiedad del objeto en el que se implementa ISomeInterface, entonces tiene un problema de referencia circular.

Una posible solución sería poner un método ClearListeners en ISomeInterface que llame a .Clear en el TList<TListenerProc> . Mientras que nada más contenga una referencia a los métodos anónimos, eso hará que todos desaparezcan y eliminen sus referencias al ISomeInterface.

He publicado algunos artículos sobre la estructura y la implementación de métodos anónimos que pueden ayudarlo a comprender con qué está trabajando realmente y cómo funcionan un poco mejor. Puede encontrarlos en http://tech.turbu-rpg.com/category/delphi/anonymous-methods .

Answer 3

Su código está lejos de ser mínimo. El seguimiento:

program AnonymousMemLeak;

{$APPTYPE CONSOLE}

uses
  SysUtils;

type
  TListenerProc  = reference to procedure (SomeInt : IInterface);

procedure MyListener (SomeInt : IInterface);
begin
end;

var
  Listener: TListenerProc;

begin
  try
    ReportMemoryLeaksOnShutdown := True;

    Listener := MyListener;
    Listener := nil;
  except
    on E: Exception do
      Writeln(E.ClassName, '': '', E.Message);
  end;
end.

tiene el mismo problema (Delphi 2009 aquí). Esto no puede ser trabajado o diseñado alrededor. Me parece un error en el compilador.

Editar:

O tal vez este es un problema de la detección de fugas de memoria. No tiene nada que ver con que el parámetro sea una interfaz, un procedimiento sin parámetros conduce a la misma "fuga". Muy extraño.