delphi - una - ¿Cómo acceder a métodos privados sin ayudantes?

llamar variable de otra clase java

Question

En Delphi 10 Seattle podría usar el siguiente código para evitar restricciones de visibilidad demasiado estrictas.

¿Cómo obtengo acceso a variables privadas?

type
TBase = class(TObject)
private
FMemberVar: integer;
end;

¿Y cómo obtengo acceso a métodos privados simples o virtuales?

type
TBase2 = class(TObject)
private
procedure UsefullButHidden;
procedure VirtualHidden; virtual;
procedure PreviouslyProtected; override;
end;

Anteriormente, usaría un ayudante de clase para abrir la clase base.

type
TBaseHelper = class helper for TBase
function GetMemberVar: integer;

En Delphi 10.1 Berlín, los ayudantes de clase ya no tienen acceso a miembros privados de la clase o registro de la asignatura.

¿Hay alguna forma alternativa de acceder a miembros privados?

Answer 1

Si desea una forma limpia que no afecte el rendimiento, aún puede acceder a campos privados desde un asistente de registro utilizando la instrucción with.

function TValueHelper.GetAsInteger: Integer;
begin
with Self do begin
Result := FData.FAsSLong;
end;
end;

Espero que mantengan este método abierto, porque tenemos código con demandas de alto rendimiento.

Answer 2

Si se genera información RTTI extendida para los miembros privados de la clase: campos y / o métodos, puede usarla para obtener acceso a ellos.

Por supuesto, acceder a través de RTTI es mucho más lento que a través de los ayudantes de clase.

Métodos de acceso:

var
Base: TBase2;
Method: TRttiMethod;
Method := TRttiContext.Create.GetType(TBase2).GetMethod(''UsefullButHidden'');
Method.Invoke(Base, []);

Acceso a variables:

var
Base: TBase;
v: TValue;
v := TRttiContext.Create.GetType(TBase).GetField(''FMemberVar'').GetValue(Base);

La información RTTI predeterminada generada para las clases RTL / VCL / FMX está siguiendo

• Campos: private , protected , public , published
• Métodos: public , published
• Propiedades public published

Desafortunadamente, eso significa que el acceso a métodos privados a través de RTTI para las bibliotecas principales de Delphi no está disponible. La respuesta de @LU RD cubre el pirateo que permite el acceso a métodos privados para clases sin RTTI extendido.

Trabajando con RTTI

Answer 3

Suponiendo que RTTI extendido no está disponible, entonces, sin recurrir a lo que se consideraría piratería, no puede acceder a miembros privados desde el código en una unidad diferente. Por supuesto, si RTTI está disponible, se puede usar.

Tengo entendido que la capacidad de descifrar miembros privados usando ayudantes fue un accidente no intencional. La intención es que los miembros privados solo sean visibles desde el código en la misma unidad, y los miembros privados estrictos solo sean visibles desde el código en la misma clase. Este cambio corrige el accidente.

Sin la capacidad de que el compilador descifre la clase por usted, necesitaría recurrir a otras formas de hacerlo. Por ejemplo, puede volver a declarar suficiente de la clase TBase para poder engañar al compilador para que le diga dónde vivía un miembro.

type
THackBase = class(TObject)
private
FMemberVar: integer;
end;

Ahora puedes escribir

var
obj: TBase;
....
MemberVar := THackBase(obj).FMemberVar; 

Pero esto es terriblemente frágil y se romperá tan pronto como se cambie el diseño de TBase .

Eso funcionará para los miembros de datos, pero para los métodos no virtuales, probablemente necesitará usar técnicas de desmontaje en tiempo de ejecución para encontrar la ubicación del código. Para los miembros virtuales, esta técnica se puede utilizar para encontrar el desplazamiento de VMT.

Otras lecturas:

• http://hallvards.blogspot.nl/2004/06/hack-5-access-to-private-fields.html
• https://bitbucket.org/NickHodges/delphi-unit-tests/wiki/Accessing%20Private%20Members

Answer 4

Todavía hay una manera de usar class helpers para acceder a métodos privados en Delphi 10.1 Berlín:

type
TBase2 = class(TObject)
private
procedure UsefullButHidden;
procedure VirtualHidden; virtual;
procedure PreviouslyProtected; override;
end;
TBase2Helper = class helper for TBase2
procedure OpenAccess;
end;
procedure TBase2Helper.OpenAccess;
var
P : procedure of object;
begin
TMethod(P).Code := @TBase2.UsefullButHidden;
TMethod(P).Data := Self;
P; // Call UsefullButHidden;
// etc
end;

Desafortunadamente, no hay forma de acceder a campos privados / privados estrictos por los ayudantes de clase con Delphi 10.1 Berlín. RTTI es una opción, pero puede considerarse lento si el rendimiento es crítico.

Aquí hay una manera de definir el desplazamiento de un campo en el inicio utilizando ayudantes de clase y RTTI:

type
TBase = class(TObject)
private // Or strict private
FMemberVar: integer;
end;
type
TBaseHelper = class helper for TBase
private
class var MemberVarOffset: Integer;
function GetMemberVar: Integer;
procedure SetMemberVar(value: Integer);
public
class constructor Create; // Executed at program start
property MemberVar : Integer read GetMemberVar write SetMemberVar;
end;
class constructor TBaseHelper.Create;
var
ctx: TRTTIContext;
begin
MemberVarOffset := ctx.GetType(TBase).GetField(''FMemberVar'').Offset;
end;
function TBaseHelper.GetMemberVar: Integer;
begin
Result := PInteger(Pointer(NativeInt(Self) + MemberVarOffset))^;
end;
procedure TBaseHelper.SetMemberVar(value: Integer);
begin
PInteger(Pointer(NativeInt(Self) + MemberVarOffset))^ := value;
end;

Esto tendrá el beneficio de que la parte RTTI lenta solo se ejecuta una vez.

Nota: Uso de RTTI para acceder a métodos protegidos / privados

El RTL / VCL / FMX no ha declarado visibilidad para acceder a métodos protegidos / privados con RTTI. Debe establecerse con la directiva local {$RTTI} .

El uso de RTTI para acceder a métodos privados / protegidos en otro código requiere, por ejemplo, la configuración:

{$RTTI EXPLICIT METHODS([vcPublic, vcProtected, vcPrivate])}

Answer 5

Si no necesita compatibilidad con el compilador ARM , puede encontrar otra solución here .

Con el ensamblador en línea, puede acceder fácilmente a un campo o método privado.

Creo que la respuesta de David es mejor en la mayoría de los casos, pero si necesita una solución rápida para una gran clase, este método podría ser más útil.

Actualización (17 de junio): Acabo de darme cuenta, olvidé compartir su código de muestra para acceder a campos privados desde su here . lo siento.

unit UnitA;
type
THoge = class
private
FPrivateValue: Integer;
procedure PrivateMethod;
end;
end.
unit UnitB;
type
THogeHelper = class helper for THoge
public
function GetValue: Integer;
procedure CallMethod;
end;
function THogeHelper.GetValue: Integer;
asm
MOV EAX,Self.FPrivateValue
end;
procedure THogeHelper.CallMethod;
asm
CALL THoge.PrivateMethod
end;

Aquí está su código de muestra para llamar al método privado .

type
THoge = class
private
procedure PrivateMethod (Arg1, Arg2, Arg3 : Integer);
end;
// Method 1
// Get only method pointer (if such there is a need to assign a method pointer to somewhere)
type
THogePrivateProc = procedure (Self: THoge; Arg1, Arg2, Arg3: Integer);
THogePrivateMethod = procedure (Arg1, Arg2, Arg3: Integer) of object;
function THogeHelper.GetMethodAddr: Pointer;
asm
{$ifdef CPUX86}
LEA EAX, THoge.PrivateMethod
{$else}
LEA RAX, THoge.PrivateMethod
{$endif}
end;
var
hoge: THoge;
proc: THogePrivateProc;
method: THogePrivateMethod;
begin
// You can either in here of the way,
proc := hoge.GetMethodAddr;
proc (hoge, 1, 2, 3);
// Even here of how good
TMethod (method) .Code := hoge.GetMethodAddr;
TMethod (method) .Data := hoge;
method (1, 2, 3) ;
end;
// Method 2
// To jump (here is simple if you just simply call)
procedure THogeHelper.CallMethod (Arg1, Arg2, Arg3 : Integer);
asm
JMP THoge.PrivateMethod
end;
unit UnitA;
type
THoge = class
private
FPrivateValue: Integer;
procedure PrivateMethod;
end;
end.