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.

[DeddyH]

Das OnChange-Ereignis soll ausgelöst werden, wenn Status geändert wird?

[spaxxn]

Hihi, du löst den Event auch gar nicht aus :P


Hast du dem OnChange eine Procedure zugewiesen?

Zitat:

Zitat von Sunshine21

Delphi-Quellcode:

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

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

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

end.

[Sunshine21]

Zitat:

Zitat von spaxxn

Hihi, du löst den Event auch gar nicht aus :P

Eigentlich doch ich wollte das machen indem ich über einen Button FStatus ändere? Aber das kann ich ja noch nicht machen da die Klasse so wie ich sie gepostet habe wohl noch nicht läuft wie sie sollte.... denke ich.

[spaxxn]

Ja ne, du musst OnChange in der Funktion/Prozedur von der du die Mitteilung über eine Änderung erhalten möchtest auch aufrufen.

[DeddyH]

Du brauchst eine Setter-Methode.

Delphi-Quellcode:

type Tmyclass = class
  ...
private
  procedure SetStatus(value: Boolean);
  ...
public
  property Status : Boolean read FStatus write SetStatus;
  ...
end;

procedure Tmyclass.SetStatus(value: Boolean);
begin
  FStatus := value;
  if Assigned(FOnChange) then
    FOnChange; 
end;

[spaxxn]

Und denke dran, dass in deinem Hauptformular(z.B.) auch eine Methode deklariert und dem OnChange zugewiesen wird.

[DeddyH]

Jepp, sonst kommt wieder nichts an :lol:

[Sunshine21]

Zitat:

Zitat von spaxxn

Und denke dran, dass in deinem Hauptformular(z.B.) auch eine Methode deklariert und dem OnChange zugewiesen wird.

Bingo, das wäre dann wohl die "Schnittstelle" zwischen den beiden die ich suche. Bloß wie mache ich das denn? Eine einfache Instanz mit der die Prozedur Onchange aufgerufen wird reicht ja nicht, oder?

Wenn ich das hinbekommen habe könnte ich nämlich alles mit austesten :)

[spaxxn]

Z.B.:

Delphi-Quellcode:

type
  TMeinFormular= Class(TForm)
  private
    procedure EineFunktion(Sender:TObject);
  end;

im Create dann noch

Delphi-Quellcode:

  MyClassInstance.OnChange_Func := EineFunktion;

[DeddyH]

Delphi-Quellcode:

type TMyForm = class(TForm)
  ...
private
  procedure DoChange; //eine Methode mit identischer Signatur wie in der Klasse
...
end;

...

procedure TMyForm.DoChange;
begin
  ShowMessage('Status geändert');
end;

procedure TMyForm.Wuppdi;
begin
  MyClass := TMyClass.Create;
  ...
  MyClass.OnChange_Func := DoChange; //Zuweisung der Routine
  ...
end;

[edit] Einen Tick zu spät [/edit]

[spaxxn]

Dafür sorgfältiger :)

[Sunshine21]

Denek ich bin jetzt schon näher dran allerdings bekomme ich momentan die Fehlermeldung "Liste der Parameter ist unterschiedlich". Was mich (unter sehr viel anderem) noch stutzig macht ist in der Klasse am Anfang

Delphi-Quellcode:

OnChange_Proc = procedure() of object;

kommt da nicht noch was in die Klammer?


Hab hier nochmal beides

Formular:

Delphi-Quellcode:

unit Unit1;

interface

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

type
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;

    procedure FormCreate(Sender: TObject);
    procedure DoChange(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);

  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

uses  TestClass;
var
     myClass : TMyclass;

//Programmstart
procedure TForm1.FormCreate(Sender: TObject);
begin
    myClass := TMyclass.Create;
    myClass.OnChange_Func := DoChange;
end;


procedure TForm1.DoChange;
begin
  ShowMessage('Status geändert');
end;


procedure TForm1.Button1Click(Sender: TObject);
begin
    myClass.Timer.enabled := NOT myClass.Timer.enabled;
end;


procedure TForm1.Button2Click(Sender: TObject);
begin
  myClass.Status := NOT myClass.Status
end;


end.

Klasse:

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);
    procedure setStatus(value: Boolean);

    public
    constructor Create;
    destructor destroy; override;
    property OnChange_Func : TOnChange_Proc read FOnChange write FOnChange;
    property Status : Boolean read FStatus write setStatus;
    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.setStatus(value: Boolean);
begin 
  FStatus := value; 
  if Assigned(FOnChange) then 
    FOnChange; 
end;

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

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

end.

[spaxxn]

Zitat:

Zitat von Sunshine21

Delphi-Quellcode:

    procedure DoChange;

Delphi-Quellcode:

    OnChange_Proc = procedure of object;

So müsste das gehen! War ein wenig in Gedanken, Aber DeddyH hats getroffen :P

Grund: Im Hauptform wurde Sender als Parameter übergeben, aber vom OnChange gar nicht angefordert. Mal in normalem deutsch ausgedrückt...

[Sunshine21]

Hi spaxxn, also irgendwas ist scheinbar immer noch faul denn jetzt kann das Formular nicht mehr erstellt werden.

Zitat:

"...es ist eine Exception der Klasse EResNotFound aufgetreten. Meldung: 'Ressource TForm1 wurde nicht gefunden"

Habe auch schon ein neues Projekt gestartet doch der Fehler bleibt.

Hab im Hauptform

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
begin
    myClass := TMyclass.Create;
    myClass.OnChange_Func := DoChange;
end;

und in der Klasse

Delphi-Quellcode:

type
    TOnChange_Proc = procedure of object;

[spaxxn]

Moment :)

Zitat:

Zitat von Sunshine21

Delphi-Quellcode:

unit Unit1;

interface

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

type
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;

    procedure FormCreate(Sender: TObject);
    procedure DoChange;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);

  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

uses  TestClass;

hier fehlt folgendes:

Delphi-Quellcode:

{$R *.dfm}

dies bindet die Formular Resourcen ein. Warum das bei dir fehlt, kann ich dir nicht sagen.

Zitat:

Zitat von Sunshine21

Delphi-Quellcode:

var
     myClass : TMyclass;

//Programmstart
procedure TForm1.FormCreate(Sender: TObject);
begin
    myClass := TMyclass.Create;
    myClass.OnChange_Func := DoChange;
end;


procedure TForm1.DoChange;
begin
  ShowMessage('Status geändert');
end;


procedure TForm1.Button1Click(Sender: TObject);
begin
    myClass.Timer.enabled := NOT myClass.Timer.enabled;
end;


procedure TForm1.Button2Click(Sender: TObject);
begin
  myClass.Status := NOT myClass.Status
end;


end.

[Sunshine21]

Zitat:

Zitat von spaxxn

Moment :)
hier fehlt folgendes:

Delphi-Quellcode:

{$R *.dfm}

[/quote]

Ups wie ist das denn schon wieder passiert? :)

Aber es nimmt kein Ende ... es ist zum Mäuse melken. Jetzt geht mein Timer auf einmal nicht mehr und ich finde einfach nicht heraus woran es liegt. Ich glaube ich muss eine Pause machen und später nocheinmal schaun denn mir qualmt der Schädel. Ich melde mich aber auf jeden Fall nochmal um zu berichten ob das TestEvent auch wirklich läuft.

[spaxxn]

Was macht denn der Timer bzw. was macht er nicht? Woran machst du fest, das er nicht mehr geht?

Quellcodetechnisch würde ich sagen, dass der rennen müsste.

[Sunshine21]

Also ich hab ja den Button 1 mit dem ich ihn starte. Mit FTimer.OnTimer := testTimer; rufe ich ja dann zyklisch testTimer auf und da hab ich mal ne showmessage zum testen eingebaut. Das ging heute auch schon mal :) Nur jetzt kommt da nix mehr geschweige denn die gewünschte Eventmeldung. Hm, aber wenn du schon nix siehst... kompiliert hast du es aber noch nicht oder?

[spaxxn]

Ich schnapp mir mal kurz den Quelltext.

Edit: Bei mir geht es!


Da die dfm nicht eingebunden war, guck mal bitte nach, ob OnClick bei den beiden Buttons überhaupt noch gebunden ist.

[Sunshine21]

Juhu! Jetzt geht es bei mir auch. Endlich gehts weiter! :) Mal schaun ob ich den Rest alleine hinbekomme.

Jedenfalls hast du mir den Tag gerettet, 1001 Dank!

[Sunshine21]

Hab mich ein wenig zu früh gefreut...

Das Programm läuft jetzt zwar aber irgendwie klappt das mit dem Timer noch nicht richtig. Wenn ich den Timer anschalte kommen sofort mit jedem Takt Nachrichtenfenster auch wenn noch keine Änderung gemacht wurde. Wenn ich auf den Button Status ändern klicke dann kommt wie gewünscht das Nachrichtenfenster. War das bei dir auch so?

[DeddyH]

Du rufst ja im Timer auch immer OnChange auf, ohne auf Änderung zu prüfen.

[Sunshine21]

Achso ich dachte das passiert automatisch :)

Muss ich jetzt den Status mit einer Hilfsvariable zwischenspeichern um vergleichen zu können oder wie macht man das am elegantesten?

[DeddyH]

Wozu brauchst Du eigentlich den Timer? Wenn sich der Status ändert, bekommst Du es doch mit.

[Sunshine21]

Leider nicht denn der Status ist ein Flag in der Windows WMI und kann sich jederzeit ändern. Der Status wird also über diese Funktion abgefragt und sollte sich was ändern soll er das der Anwendung melden.

[DeddyH]

Dann wäre es IMO wirklich besser, sich den alten Status zu merken und zu vergleichen.

[Sunshine21]

Zitat:

Zitat von spaxxn

Zitat:

Zitat von Sunshine21

Delphi-Quellcode:

    procedure DoChange;

Delphi-Quellcode:

    OnChange_Proc = procedure of object;

So müsste das gehen! War ein wenig in Gedanken, Aber DeddyH hats getroffen :P

Grund: Im Hauptform wurde Sender als Parameter übergeben, aber vom OnChange gar nicht angefordert. Mal in normalem deutsch ausgedrückt...

Da hätte ich noch eine kurze Frage dazu. Wenn ich Parameter übergeben möchte müssen die dann in der Klasse in

Delphi-Quellcode:

    OnChange_Proc = procedure (Parameter1 : string, Parameter2 : Boolean) of object;

angegeben werden oder im Hauptform

Delphi-Quellcode:

procedure DoChange(Parameter1 : string, Parameter2 : Boolean)

oder gar beides?

++++++++++++++++++++++++++++++++++++++++++++++++++ ++++++++++++

"Nur" fürs Verständnis....

Delphi-Quellcode:

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

procedure TMyClass.setStatus(value: Boolean);
begin
  FStatus := value;
  if Assigned(FOnChange) then
    FOnChange;
end;

Wie genau funktioniert das mit dem Assigned

[DeddyH]

Zitat:

Delphi-Quellcode:

OnChange_Proc = procedure (Parameter1 : string, Parameter2 : Boolean) of object;

Genauso geht das. Die zuzuweisende Methode muss dann dieselbe Signatur (also die selben Parameter) besitzen. Und Assigned prüft, ob eine Methode zugewiesen wurde. Im Detail heißt das, es wird nachgesehen, ob der Methodenzeiger nil ist.

[spaxxn]

Woran lag es? würde mich interessieren? OnClick nicht gebunden gewesen?

[Sunshine21]

Hallo spaxxn, hatte es gestern zum laufen gebracht als ich einfach vor dem Kompilieren die Buttons durch doppelklick auf dem Formular eingebunden habe (glaube das geht doch so, oder?)

Leider verstehe jetzt gar nichts mehr. Wollte nochmal ein neues Projekt starten und jetzt kommt wieder eine Fehlermeldung sobald ich einen der beiden Button drücke:
Exception-Klasse EAccessViolation mit Meldung 'Zugriffsverletzung bei Adresse 0045C365 in Modul 'Project1.exe'. Lesen von Adresse 00000004'. Prozess Project1.exe (1472)
Was hab ich jetzt schon wieder falsch gemacht?

Kannst du nochmal kurz versuchen ob die beiden Units 1:1 bei dir Laufen? Arbeite nämlich auf zwei unterschiedlichen Rechner und will ausschliessen dass es am Code liegt.