IOTA-Frage zur Callbarkeit von Procs unterschiedlicher Notifier untereinander

[Uwe Raabe]

Zitat von r29d43:

Was aber aufgrund der in IOTA-Packages fehlenden <IdeNotifer : TIDENotifer> -Zeile da jetzt leider nicht geht.

Würde es das geben, wie sollte man dann mit mehreren Notifier-Instanzen des gleichen Typs umgehen?

(Das gilt übrigens analog auch für mehrere Form-Instanzen, weshalb diese globalen Variablen für viele Entwickler sogar tabu sind und gezielt gelöscht werden.)

[r29d43]

@himitsu. Kannst du das vllt. noch etwas genauer erklären? Thx.


@Uwe Raabe. Genauso wie ich auch mit mehreren Form-Instanzen eines gleichen Form-Typs umgehen würde? Die ich dann nämlich gleich dynamisch erzeugen würde. Und dann wäre auch der Rest meines Progs schon darauf eingestellt und könnte damit auch umgehen.

[Uwe Raabe]

Zitat von r29d43:

Genauso wie ich auch mit mehreren Form-Instanzen eines gleichen Form-Typs umgehen würde? Die ich dann nämlich gleich dynamisch erzeugen würde. Und dann wäre auch der Rest meines Progs schon darauf eingestellt und könnte damit auch umgehen.

Aber erzeugst du die Notifier nicht auch dynamisch?

[r29d43]

Zitat von Uwe Raabe:

Aber erzeugst du die Notifier nicht auch dynamisch?

Besten Dank für den Tipp, hat funktioniert.

Ich habe das obige Beispiel jetzt in der Register-Proc dementsprechend umgebaut, so dass ich nun faktisch die gleichen Bedingungen habe, wie in einem normalen Delphi-Prog bzgl. der dort jeweils deklarierten Formularen:

Delphi-Quellcode:

unit readEditorCode_Unit; 

interface

uses ToolsAPI, Winapi.Windows, Winapi.Messages, Registry, vcl.ExtCtrls, vcl.Controls, system.Rtti,

TIDENotifier = class(TNotifierObject, IOTANotifier, IOTAIDENotifier)
    Timer1 : TTimer;
    procedure Timer1Timer(Sender: TObject);
  private
    ...
  public
    // IOTAIDENotifier
    VarXYZ : integer;           // <--------
    procedure FileNotification(NotifyCode: TOTAFileNotification; const FileName: string; var Cancel: Boolean);
    procedure BeforeCompile(const Project: IOTAProject; var Cancel: Boolean); overload;
    procedure AfterCompile(Succeeded: Boolean); overload;
    constructor Create;
    destructor Destroy; override;
    procedure ProcABC;           // <--------
  end; { of "TIDENotifier = class() }

var
  IDENotifier1 : TIDENotifier;
  NotifierIndex: Integer = -1;

procedure Register;

implementation

uses vcl.Dialogs, system.SysUtils, shellapi, EditServiceNotifer;

procedure Register;
var
  Services: IOTAServices;
begin
  if not Supports(BorlandIDEServices, IOTAServices, Services) then Exit;
  IDENotifier1 := TIDENotifier.Create;
  NotifierIndex := Services.AddNotifier(IDENotifier1);
end;

usw. usf..

[himitsu]

Nein, niemals Objekt-Referenzen und Interfaces mischen.

Gib deinen Klassen zusätzlich ein "eigenes" Interface, und speichere dir davon die Referenz in einer Variable.

Delphi-Quellcode:

type
  IMyIDENotifier = interface
    function GetXYZ: Integer;
    procedure SetXYZ(Value: Integer);

    procedure ProcABC;
    property XYZ: Integer read GetXYZ write SetXYZ;
  end;

  TMyIDENotifier = class(TNotifierObject, IOTANotifier, IOTAIDENotifier, IMyIDENotifier)
    Timer1 : TTimer;
    procedure Timer1Timer(Sender: TObject);
  private
    FXYZ : integer;
    function GetXYZ: Integer;
    procedure SetXYZ(Value: Integer);
  protected
    // IOTAIDENotifier
    procedure FileNotification(NotifyCode: TOTAFileNotification; const FileName: string; var Cancel: Boolean);
    procedure BeforeCompile(const Project: IOTAProject; var Cancel: Boolean); overload;
    procedure AfterCompile(Succeeded: Boolean); overload;
  public
    constructor Create;
    destructor Destroy; override;
    // IMyIDENotifier
    procedure ProcABC;
    property XYZ: Integer read GetXYZ write SetXYZ;
  end; { of "TIDENotifier = class() }

var
  MyIDENotifier: IMyIDENotifier;
  NotifierIndex: Integer = -1;

procedure Register;

implementation

procedure Register;
var
  Services: IOTAServices;
begin
  if not Supports(BorlandIDEServices, IOTAServices, Services) then Exit;
  MyIDENotifier := TIDENotifier.Create;
  NotifierIndex := Services.AddNotifier(MyIDENotifier as IOTANotifier);

Im Interface ist alles Public,
aber was wo in der Klasse ist, ist dem Objekt egal. Hauptsache die Methoden existieren irgendwo und sind von der Position aus zugreifbar,
was auch in einem Vorfahren sein kann, wie z.B. die Methoden für IOTANotifier und IInterface.


Und nicht zu vergessen:

Delphi-Quellcode:

finalization  // oder "class destructor TMyIDENotifier.Destroy;"
  ...
  MyIDENotifier := nil;
  Services.RemoveNotifier(NotifierIndex);

[r29d43]

Dank auch dafür.

Zitat von himitsu:

Nein, niemals Objekt-Referenzen und Interfaces mischen.

Gib deinen Klassen zusätzlich ein "eigenes" Interface, und speichere dir davon die Referenz in einer Variable.

Allerdings solltest du jetzt event. auch noch genau erklären warum. (Weil meine Lösung sieht dagegen ja eigentlich viel naheliegender und einfacher aus).

[stahli]

Wenn die Interfaces das automatische Reference Counting nutzen kannst Du sonst nicht sicher sein, dass das Objekt nicht bereits freigegeben wurde während Du die Objektvariable noch benutzt.

[TiGü]

Zitat von r29d43:

Dank auch dafür.

Zitat von himitsu:

Nein, niemals Objekt-Referenzen und Interfaces mischen.

Gib deinen Klassen zusätzlich ein "eigenes" Interface, und speichere dir davon die Referenz in einer Variable.

Allerdings solltest du jetzt event. auch noch genau erklären warum. (Weil meine Lösung sieht dagegen ja eigentlich viel naheliegender und einfacher aus).

Du bist seit 14 Jahren hier im Forum und wirst doch schonmal mitbekommen haben warum man das nicht macht.
Objekt-Referenzen und Interfaces mischen