Eigene Ereignisse auslösen

[Sir Rufo]

Zitat:

Zitat von Jonas Shinaniganz (Beitrag 1260254)

Zitat:

Dann geht der Wert direkt in das Feld und wird nicht über das Property umgeleitet.

Stimmt hatte vergessen "strict private" drauß zu machen, aber man müsste schon explizit FZbetr beschreiben um den Setter zu umgehen.

Und das ändert jetzt was? :gruebel:

[Jonas Shinaniganz]

Reden wir aneinander vorbei? Den Setter kann man nicht umgehen, es handelt sich doch um eine globale Version des Records. Oder wird die komplette Record-Variable überschrieben?

[Sir Rufo]

Zitat:

Zitat von Jonas Shinaniganz (Beitrag 1260263)

Den Setter kann man nicht umgehen, es handelt sich doch um eine globale Version des Records. Oder wird die komplette Record-Variable überschrieben?

Der Speicherbereich des Records wird überschrieben und da kannst du die Variablen so

Delphi-Quellcode:

strict private

machen wie du möchtest, sie werden trotzdem ohne den Setter zu benutzen geändert.

[Jonas Shinaniganz]

Ja aber an irgendeiner Stelle muss ja der Record belegt werden, ob jetzt dann oder davor. In dem Moment fliegt dann das Event.

Delphi-Quellcode:

  TMyRec = record
  strict private
    FNichtBeschreibbar: Boolean;
    procedure SetNichtBeschreibbar(const Value: Boolean);
  public
    property NichtBeschreibbar : Boolean read FNichtBeschreibbar write SetNichtBeschreibbar;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

{ bla }

procedure TMyRec.SetNichtBeschreibbar(const Value: Boolean);
begin
  FNichtBeschreibbar := Value;
end;

procedure TForm1.FormCreate(Sender: TObject);
var
  MyRec : TMyRec;
  MyRec2 : TMyRec;
begin
  MyRec.NichtBeschreibbar := True;
  MyRec2.NichtBeschreibbar := False; // dann halt hier

  MyRec := MyRec2; // und nicht hier

end;

Aber das hilft jetzt glaube ich nicht wirklich dem Suchenden

[akurka]

Hallo Sir Rufo
Danke für Dein Vorschlag, etwas ist mir nicht ganz klar.

Zitat:

procedure TMyClass.Execute;
var
LStatus : TCNCStatus;
begin
inherited;
while not Terminated do
begin
// Warten auf ein Empfangs-Signal

// Irgendwie den Status empfangen
LStatus := ...

// öffentlichen Status setzen
SetStatus( LStatus );
end;
end;

Heisst es, dass ich die Komponente für ComPort(TVaComm) gar nicht benützen muss und direkt WinAPI funktionen brauchen an diesen Stellen ??
(// Warten auf ein Empfangs-Signal resp. // Irgendwie den Status empfangen)

Nur taucht da ein anderes Problem auf.
Von der CNC kommt nicht nur Status, sondern auch andere Meldungen mit
unterschiedliche länge, die müssen dann in den etsprechenden Records gespeichert werden (für spätere Anzeige)
wobei dies natürlich auch im Hintergund soll ablaufen.
Die Reihenfolge der Meldungen ist beliebig !
Gruss
Anton

[Sir Rufo]

Zitat:

Zitat von Jonas Shinaniganz (Beitrag 1260267)

Aber das hilft jetzt glaube ich nicht wirklich dem Suchenden

Vor allem weil er den Record so nicht befüllt!

[Jonas Shinaniganz]

akurka, poste doch mal bitte wo du den Record befüllst, wenn das möglich ist.

Ich empfehle dir nochmals (weil es eine wirklich durchdachte Implementation ist) einen Blick in die AsyncPro Bibliothek zu werfen (speziell Datapackages). Es gibt auch eine gute Dokumentation dazu.

[Sir Rufo]

Zitat:

Zitat von Jonas Shinaniganz (Beitrag 1260272)

akurka, poste doch mal bitte wo du den Record befüllst, wenn das möglich ist.

Ich empfehle dir nochmals (weil es eine wirklich durchdachte Implementation ist) einen Blick in die AsyncPro Bibliothek zu werfen (speziell Datapackages). Es gibt auch eine gute Dokumentation dazu.

Es ist völlig unerheblich, wie er den Record befüllt. So sollte man das definitiv nicht machen (es sei denn man möchte sich unkontrollierte Probleme einhandeln).
Wenn du dem Record einen Event spendierst und dann den Record aus einem Stream lädst, dann ist auch die Zuweisung für den Event entweder leer (im besten Fall) oder der Event zeigt irgendwo ins Nirwana und die Hütte fliegt dir um die Ohren.

Betrachte einen Record so, wie du einen einfachen Typen wie z.B. integer betrachtest (als einen einfachen Wert).

[Sir Rufo]

@akurka

Im OOP-Geschäft muss man etwas abstrakter denken (damit das auch Sinn macht und das Leben vereinfacht).

z.B. Die Komponente für den Com-Port sorgt für den Datenaustausch (Protokoll) und nicht mehr.
Sie weiß, wie groß die Pakete sind (ist Bestandteil des Protokolls) und übergibt diese Pakete an eine weitere Instanz, die weiß, wie man aus diesen Paketen (eine Handvoll Bytes) sinnvolle Strukturen erzeugt.

Etwas Ähnliches (mit Klassen) gibt es hier http://www.delphipraxis.net/180297-b...iebereien.html

Delphi-Quellcode:

unit BaseDataFactory;

interface

uses
  System.Generics.Collections,
  System.Classes,
  System.SysUtils,
  BaseData;

type
  TBaseDataClass = class of TBaseData;

  TBaseDataFactory = class
  private
    class var _Types : TDictionary<Byte, TBaseDataClass>;
  protected
    class constructor Create;
    class destructor Destroy;
  public
    class function CreateFromStream( AStream : TStream ) : TBaseData;
    class procedure RegisterType( AType : Byte; AClass : TBaseDataClass );
  end;

implementation

{ TBaseDataFactory }

class constructor TBaseDataFactory.Create;
begin
  _Types := TDictionary<Byte, TBaseDataClass>.Create;
end;

class function TBaseDataFactory.CreateFromStream( AStream : TStream ) : TBaseData;
var
  LType : Byte;
  LSize : Byte;
  LData : TBytes;
  LClass : TBaseDataClass;
begin
  AStream.Read( LType, SizeOf( LType ) );
  AStream.Read( LSize, SizeOf( LSize ) );
  SetLength( LData, LSize );
  AStream.Read( LData, LSize );

  LClass := _Types[LType]; // Bei einem unbekannten Typen wird hier eine Exception geworfen
  Result := LClass.Create( LData );
end;

class destructor TBaseDataFactory.Destroy;
begin
  _Types.Free;
end;

class procedure TBaseDataFactory.RegisterType( AType : Byte; AClass : TBaseDataClass );
begin
  _Types.AddOrSetValue( AType, AClass );
end;

end.

In die andere Richtung geht es genauso (nur umgekehrt).

Einer weiß, wie man aus einer Informationsstruktur (z.B. ein Record) eine Byte-Folge machen kann, übergibt diese Byte-Folge an jemand anderes, der Byte-Folgen versenden kann, der wiederum weiß, dass das über den Com-Port erfolgen muss.

[Jonas Shinaniganz]

Okay vielleicht fällt es mir auch nur zu schwer, mich da in etwas hineinzudenken was ich nicht sehe :) In dem was du sagst stimme ich zu.

akurka, schau einmal hier in den Guide. In der Sektion Datapackages. http://tpapro.sourceforge.net/docs/A...renceGuide.pdf

Diese Bibliothek ist so mächtig das der serielle Stream vor ihr erzittert :]