Как получить доступ к приватным методам без помощников?

Question

В Delphi 10 Seattle я мог бы использовать следующий код, чтобы обойти слишком строгие ограничения видимости.

Как получить доступ к закрытым переменным?

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

И как получить доступ к простым или виртуальным частным методам?

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

Previously I would use a class helper to break open the base class.

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

В Delphi 10.1 Берлин, класс хелперы больше не имеют доступа к закрытым членам класса объекта или записи.

Есть ли альтернативный способ доступа к частным членам?

Answer 1

Если удлиняется RTTI информация генерируется для частных членов класса - поля и/или методы, которые вы можете использовать его, чтобы получить доступ к их.

Конечно, доступ через RTTI намного медленнее, чем через посредников классов.

методы Доступ:

var 
    Base: TBase2; 
    Method: TRttiMethod; 

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

Доступ к переменным:

var 
    Base: TBase; 
    v: TValue; 

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

---

По умолчанию RTTI информация генерируется для RTL/VCL/FMX классов имеет следующие

• Поля - private, protected, public, published
• Методы - public, published
• Свойства - public, published

К сожалению, это означает, что доступ к частным методам с помощью RTTI для основных библиотек Delphi не доступен , @LU RD's answer охватывает хак, который позволяет доступ к частному методу для классов без расширенного RTTI.

Working with RTTI

Answer 2

Предполагая, что расширенный RTTI недоступен, то, не прибегая к тому, что можно считать взломом, вы не можете получить доступ к частным членам из кода в другом блоке. Конечно, если RTTI доступен, он может быть использован.

Я понимаю, что способность взломать частных членов с помощью помощников была непреднамеренной случайностью. Предполагается, что частные члены могут быть видны только из кода в одном блоке, а строгие частные члены видны только из кода в том же классе. Это изменение исправляет несчастный случай.

Не имея возможности заставить компилятор взломать класс для вас, вам нужно прибегнуть к другим способам этого. Например, вы можете повторно объявить достаточно класса TBase, чтобы уловка компилятора могла сообщить вам, где жил член.

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

Теперь вы можете написать

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

Но это чудовищно хрупкими и сломается, как только расположение TBase изменяется.

Это будет работать для членов данных, но для не виртуальных методов вам, вероятно, потребуется использовать методы разборки времени выполнения, чтобы найти местоположение кода. Для виртуальных участников этот метод можно использовать для поиска смещения VMT.

Дальнейшее чтение:

• 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 3

Если вам не нужна поддержка ARM компилятор, вы можете найти другое решение here.

С встроенным ассемблером вы можете легко получить доступ к частному полю или методу.

Я думаю David's answer лучше в большинстве случаев, но если вам нужно быстрое решение для огромных класса, этот метод может быть более полезным.

Update (17 июня): Я только что заметил, что я забыл поделиться своим образец кода для доступ частных полей от его post. Прости.

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; 

Вот его пример кода для вызова частный метод.

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. 

Answer 4

Существует еще способ использовать class helpers для доступа частных методов в Delphi 10.1 Берлине:

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; 

---

К сожалению, нет никакого способа, чтобы получить доступ строгих личные/частные полей помощниками класса с Delphi 10.1 Berlin. RTTI - это вариант, но его можно считать медленным, если производительность критическая.

Вот способ определить смещение в поле при запуске с помощью класса хелперы и 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; 

Это будет иметь преимущество, что медленная RTTI часть выполняется только один раз.

---

Примечание: Использование RTTI для доступа охраняемых/частных методов

The RTL/VCL/FMX не объявленных видимости для доступа охраняемых/частных методов с RTTI. Он должен быть установлен с локальной директивой {$RTTI}.

Использование RTTI для доступа частных/защищенных методов в другом коде требует, например установок:

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

Answer 5

Если вы хотите чистый способ, который не влияет на производительность, вы можете получить доступ к частному полю из записывающего помощника, используя оператор with.

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

Надеюсь, они оставят этот метод открытым, потому что у нас есть код с высокими требованиями к производительности.