Klasse soll Anwendung nur bei best. Änderung benachrichtigen

[Sunshine21]

Hallo Deutschland (3:2) ):)

Ich glaube ich brauch professionelle Hilfe.

Ich habe hier ein Klasse die ich in einer extra Unit gespeichert habe. Sämtliche Funktionen und Prozeduren (auch ein Timer ist dabei) funktionieren soweit ganz gut. Ich rufe sie in meiner Anwendung auf und kann dann auf freigegebene Variablen je nach Berechtigung zugreifen.

Jetzt würde ich aber aus dieser Klasse gerne eine Art Komponente entwickeln, welche permanent alles im Hintergrund abwickelt und nur bei bestimmten Änderungen von Statusvariablen eine Nachricht an meine Anwendung sendet. Momentan wird die Klasse nur per Timer in der Anwendung aufgerufen.

Was mir absolut unklar ist, ist wie ich die Verbindung zwischen Klasse und Hauptanwendung hinbekommen soll, damit die Klasse selbst von alleine den Zustand überprüft und die Hauptanwendung nur dann einen Bescheid bekommt, wenn sich in der Klasse auch wirklich etwas geändert hat.

Ich habe der besseren Übersicht mal eine einfache Klasse erstellt, in der ein Timer jeweils den Rückgabewert einer Funktion für zwei Typen prüft. Jetzt sollte eine Nachricht an die Anwendung geschickt werden, sobald sich einer der beiden Status ändert.

Ich hoffe, dass ich mich einigermaßen verständlich ausgedrückt habe und natürlich auch, dass ihr mir helfen könnt :)

Delphi-Quellcode:

unit Unit2;

interface

uses
    Windows, Messages, SysUtils, Variants, Classes, Graphics, Forms, Dialogs,
    StdCtrls, ExtCtrls;

type
    TType = (type1, type2);
    TMyClass = class(TObject)

    private
    FTimer              : TTimer;
    FStatus             : Boolean;

    function  getAvailable(t: TType): Boolean;
    procedure testTimer(Sender : TObject);

    public
    constructor Create;
    destructor destroy; override;

    property Available [t : TType] : Boolean read GetAvailable;
    property Timer : TTimer read FTimer write FTimer;
end;

implementation

constructor TMyClass.Create;
begin
inherited;
    FTimer := TTimer.Create(nil);
    FTimer.enabled := false;
    FTimer.Interval := 1000;
    FTimer.OnTimer := testTimer;
end;

destructor TMyClass.Destroy;
begin
    FTimer.Free;
    inherited;
end;

function TMyClass.GetAvailable(t: TType): Boolean;
begin
  if FStatus = true then
  result := true
  else
  result := false
end;

procedure TMyClass.testTimer(Sender:TObject);
begin
    GetAvailable(type1);
    GetAvailable(type2);
end;

end.

Einen lieben Gruß

Sunshine

[spaxxn]

Erstmal ein herzlich Willkommen in der DP :dp:

Wieweit sind den deine Programmierkenntnisse überhaupt fortgeschritten?

Deine Fragestellung würde nahelegen einen Callbackevent dafür zu verwenden.

[hoika]

Hallo,

die Frage ist, was soll deine Hauptanwendung genau machen,
wenn sich Änderungen ergeben und sie darüber benachrichtigt werden soll ?

wenn es nur irgendeine Status-Anzeige ist,
reicht ein Event.

Soll die Hauptanwendung unterbrochen werden,
wird es gaaanz schwierig.

Ein Event ist vereinfacht gesagt eine Prozedur-Variable in deiner Timer-Klasse,
die Prozedur ist Teil deiner Hauptanwendung.
Durch Aufruf der "Variable" wird die Prozedur deiner Hautpanwendung aufgerufen.


Heiko

[Sunshine21]

Hi spaxxn,

meine Kenntnisse sind definitiv noch im Anfangstatus. Habe mir das was ich bis jetzt kann aus "Borland Delphi 7" von Doberenz und diversen Beiträgen aus diesem Forum angeignet.

In dem Buch steht unter Komponentenentwicklung auch etwas über Ereignisse und Ereignisprozeduren. Das könnte doch ein richtiger Weg sein, oder? Ich bräuchte demnach sowas wie

Delphi-Quellcode:

 Procedure (...) of Object

aber wie das genau gehen soll ist mir noch zu hoch.

[Sunshine21]

Hallo hoika,

also die Hauptanwendung soll nicht unterbrochen werden. Sondern ersteinmal nur benachrichtigt werden wenn sich was geändert hat. Das mit dem Event klingt jedenfalls gut, nur wie würde das denn in meiner Beispielklasse oben ausschauen?

[spaxxn]

Da bist du schon auf dem richtigen Weg.

Ich sag erstmal nur soviel, du kannst so ein Event in dein Objekt einbinden. Dem Event kannst du dann später eine Funktion z.B. aus deiner Hauptanwendung zuweisen.

Delphi-Quellcode:

interface
  TOnChange_Proc = procedure() of object;

  TmyObject = class(TObject)
  private
    FOnChange :  TOnChange_Proc;
    procedure OnChange;
  public
    constructor Create;
    destructor Destroy; override;
    property OnChange_Func : TOnChange_Proc read FOnChange write FOnChange;
  end;

implementation

procedure TmyObject.OnChange;
begin
  if Assigned(OnChange_Func) then
    OnChange_Func;
end;

Ist jetzt nur auf die schnelle aus dem Kopf

[DeddyH]

Kleine Ergänzung/Änderung:

Delphi-Quellcode:

constructor Tmyobject.Create;
begin
  //...
  FOnChange := nil;
end;

procedure TmyObject.OnChange;
begin
  if Assigned(FOnChange) then
    FOnChange;
end;

[spaxxn]

Klugscheißer :cheers:

Aber das mit dem Create stimmt schon, hätte ich jetzt aber vorausgesetzt ...

[DeddyH]

Zitat:

Zitat von spaxxn

Klugscheißer

Lass mich doch auch mal :zwinker: :cheers:

[Sunshine21]

Sorry aber ich komme da nicht mit. Ich weiß jetzt ungefähr was ich in meine Klasse alles schreiben soll allerdings wars das auch schon. Meine Hauptverständnisschwierikeiten liegen noch immer in der Verbindung der Klasse mit der Anwendung.

Sprich: "Wie kommuniziert die Klasse mit der Anwendung?"

Vielleicht kannst du deine Codezeilen kurz kommentieren. Habe mal versucht die BeispielKlasse von mir so weit es geht abzuändern jedoch fehlt da noch Grundlegendes. Es soll wenn sich FStatus ändert in der Anwendung gemeldet werden.

Testen würde ich das Ganze erstmal über ein Formular indem ich über einen Button FStatus ändere und auf eine Meldung warte (wo wir wieder bei meinem Verständnisproblem wären). Davon schein ich allerdings noch meilenweit entfernt zu sein :stupid:

Delphi-Quellcode:

 type
    TOnChange_Proc = procedure() of object;

Fehlt hier nicht noch was?

Delphi-Quellcode:

unit Testclass;

interface

uses
    Windows, Messages, SysUtils, Variants, Classes, Graphics, Forms, Dialogs,
    StdCtrls, WinSock, ActiveX, ComObj, ExtCtrls;

type
    TOnChange_Proc = procedure() of object;
    TMyClass = class(TObject)

    private
    FTimer              : TTimer;
    FStatus             : Boolean;
    FOnChange           : TOnChange_Proc;

    procedure OnChange;
    function  getAvailable: Boolean;
    procedure testTimer(Sender : TObject);

    public
    constructor Create;
    destructor destroy; override;
    property OnChange_Func : TOnChange_Proc read FOnChange write FOnChange;
    property Status : Boolean read FStatus write FStatus;
    property Timer : TTimer read FTimer write FTimer;
end;

implementation

constructor TMyClass.Create;
begin
inherited;
    FTimer := TTimer.Create(nil);
    FTimer.enabled := false;
    FTimer.Interval := 1000;
    FTimer.OnTimer := testTimer;
    FOnChange := nil;
end;

destructor TMyClass.Destroy;
begin
    FTimer.Free;
    inherited;
end;

procedure TMyClass.OnChange;
begin
  if Assigned(FOnChange) then
    FOnChange;
end;

procedure TMyClass.testTimer(Sender:TObject);
begin
    GetAvailable;
    ShowMessage('Timer läuft auch')
end;

function TMyClass.GetAvailable: Boolean;
begin
  if FStatus = true then
  result := true
  else
  result := false
end;

end.