Obtener lista de procedimientos de un objeto

[dec]

Hola,

Observa el "TTypeKind" Román, el que se utiliza en la sentencia "if" en el código anterior, es decir, se mira si lo que tenemos entre manos es un "tkMethod".

Ahora echa un vistazo al artículo de Brian Long y mira lo que dice de este "TTypeKind":

tkMethod: Procedure and function method types value

Yo me he venido guiando por eso. Cierto que los "OnCreate", "OnShow", etc., son propiedades de "TForm", pero, no es menos cierto que el código de arriba los lista cuando le pedimos que liste "tkMethod".

No sé. La verdad es que creo comprender lo que dices perfectamente Román. Quizás todo esto no es más que producto de la poca información de la que se dispone sobre estas cuestiones.

[roman]

A ver, tkMethod no significa que tengamos un método entre manos, sino que tenemos una propiedad cuyo tipo de datos es un método. Recuerda, por ejemplo, qué esTNotifyEvent:

Código Delphi [-]
type
  TNotifyEvent = procedure (Sender: TObject) of object;

TNotifyEvent es un tipo de datos; el tipo procedimiento (de objeto).

Si te fijas, la misma función que mencionas, GetPropList, justamente, lo que obtiene es una lista de propiedades, no de métodos, sólo propiedades.

Cuando haces:

Código Delphi [-]
if ( propsInfo^[i].PropType^.Kind = tkMethod ) then

estás aislando sólo aquellas propiedades cuyo tipo de datos es un procedimiento (o función) lo cual incluye todos los eventos (por cierto, se pueden definir eventos que devuelven valores; funciones, aunque nunca he visto uno).

En resumen, no es lo mismo método, que propiedad tipo método.

Si pones

Código Delphi [-]
type
  TMiTipoEvento = procedure (...) of object;

  TForm1 = class(TForm)
  published
    property Algo: Integer;
    property PasaAlgo: TMiTipoEvento;

    procedure HazAlgo;
  end;

GetPropList te listará Algo y PasaAlgo (mostrando que lo que mencioné en el mensaje anterior no es cierto) pero no listará HazAlgo. HazAlgo es un método mientras que PasaAlgo es un propiedad.

// Saludos

[dec]

Hola,

Empezado por Román

GetPropList te listará Algo y PasaAlgo (mostrando que lo que mencioné en el mensaje anterior no es cierto) pero no listará HazAlgo. HazAlgo es un método mientras que PasaAlgo es un propiedad.

Correcto. Llevas toda la razón. Ése es el quid del asunto, pues. Efectivamente ahora consigo que se liste "PasaAlgo", discriminando por el "TypeKind" "tkMethod".

Pues entonces la cosa parece más o menos clara. La cuestión es que debo haber soñado que era posible conseguir también los métodos que no fueran precisamente propiedades...

O lo he soñado, o es que en C# sí que es posible hacer esto, es decir, que puedo estar confundiendo lo que es posible en C# (en este caso) y lo que es posible en Delphi.

Bueno. La cosa queda más o menos clara, pues. Gracias Román. Lo que no sé yo es que pensará el compañero que inició este Hilo, ya nos contará algo, digo yo.

[rounin]

En principio es possible obtener los "published" metodos de una clase.
Pero no es possible obtener la lista de argumentos.
(Eso es possible, por ejemplo, para metodos de seccion "automated").

Código Delphi [-]
unit main;
interface
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls,
  PubMeth;
type
  TForm1 = class(TForm)
    BShowMethods: TButton;
    ListBox1: TListBox;
    procedure BShowMethodsClick(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;
  {$M+}
  TTest1 = class
  published
    procedure Test1; virtual; abstract;
  end;
  TTest2 = class(TTest1)
  published
    procedure Test2; virtual; abstract;
  end;
var
  Form1: TForm1;
implementation
{$R *.dfm}
procedure TForm1.BShowMethodsClick(Sender: TObject);
var
  MethodIterator: TPublishedMethodIterator;
  Cls: TClass;
begin
  ListBox1.Clear;
  MethodIterator := TPublishedMethodIterator.Create;
  Cls := TTest2; //ClassType;
  try
    with MethodIterator do
    begin
       while Cls <> nil do
       begin
        Init(Cls);
        ListBox1.Items.Add(Format('%s, %d methods',[TClass(VMT).ClassName, GetMethodCount]));
        First;
        while (Current <> nil) do
        begin
          ListBox1.Items.Add(Format('     %s: $%p',[Current^.Name, Current^.Address]));
          Next;
        end;
         Cls := Cls.ClassParent;
       end;
    end;
  finally
    MethodIterator.Free;
  end;
end;
end.
 
{-----------------------------------------------------------------------}
 
unit PubMeth; 
interface
uses
 Classes, TypInfo;
type
 PVmtMethod = ^TVmtMethod;
 TVmtMethod = packed record
   Size: Word;
   Address: Pointer;
   Name: ShortString;
 end;
 PVmtMethodTable = ^TVmtMethodTable;
 TVmtMethodTable = packed record
   Count: Word;
   Methods: array [0..MaxListSize] of byte;
   {    Methods : array [0..Count] of TVmtMethod;}
 end;
 TPublishedMethodIterator = class
 private
   FVMT: Pointer;
   FMethodTable: PVmtMethodTable;
   FCurrent: PVmtMethod;
   FCurrentIndex: Integer;
   function CurrentLength: Integer;
 public
   property VMT: Pointer read FVMT;
   property Current: PVmtMethod read FCurrent;
   function GetMethodCount: Integer;
   procedure Init(AClass: TClass);
   function First: PVmtMethod;
   function Next: PVmtMethod;
 end;
function OffsetPtr(P: Pointer; Offset: Integer): Pointer;
implementation
function OffsetPtr(P: Pointer; Offset: Integer): Pointer;
begin
  Integer(Result) := Integer(P) + OffSet;
end;
{ TPublishedMethodIterator }
function TPublishedMethodIterator.GetMethodCount: Integer;
begin
  Result := 0;
  if not Assigned(FMethodTable) then Exit;
  Result := FMethodTable^.Count;
end;
procedure TPublishedMethodIterator.Init(AClass: TClass);
begin
  FMethodTable := nil;
  FVMT := Pointer(AClass);
  FMethodTable := Pointer( OffsetPtr(FVMT, vmtMethodTable)^ );
  FCurrent := nil;
end;
function TPublishedMethodIterator.First: PVmtMethod;
begin
  Result := nil;
  FCurrentIndex := 0;
  if not Assigned(FMethodTable) then Exit;
  FCurrent := Pointer(@FMethodTable.Methods[0]);
  Result := FCurrent;
end;
function TPublishedMethodIterator.CurrentLength: Integer;
begin
  Result := 0;
  if not Assigned(FCurrent) then Exit;
  Result := Current^.Size; // SizeOf(Word) + SizeOf(Pointer) + Length(Current^.Name) + 1;
end;
function TPublishedMethodIterator.Next: PVmtMethod;
begin
  Result := nil;
  if not Assigned(FMethodTable) then Exit;
  if FCurrentIndex + 1 >= GetMethodCount then
  begin
    FCurrent := nil;
  end
  else
  begin
    FCurrent := OffsetPtr(FCurrent, CurrentLength);
    Inc(FCurrentIndex);
  end;
  Result := FCurrent;
end;
end.

[dec]

Hola,

Muchas gracias por tu código fuente Rounin.