Events && E2347

private:
typedef void __fastcall (__closure *TSend)(TCustomWinSocket*, AnsiString, signed __int16);
typedef void __fastcall (__closure *TExecQuery)(AnsiString);
//...
public:
__property TExecQuery ExecQuery = {};
__property TSend Send = {read=FSend, write=FSend};
//...
void __fastcall FSend (TCustomWinSocket* Socket, AnsiString value, signed __int16 to)
{
//...halt die Funktion...
}

a->ExecQuery = b->execquery;

(in meiner Main-Form)

das war ein teil des quellcodes für mehrere (hier 2 ^^) Events, die ich festgelegt habe - um halt auf bestimmt Ereignisse reagieren zu können - eins dieser Events muss ich direkt auf eine andere Klasse verlinken-das kann ich aber nicht andersrum machen, weil ich die beiden Klassen in meiner Main-Form einbinde und ich nciht vorhabe hin und her zu includen...

Fehlermeldung ist übrigens die 2347 (Parameter mismatch in read {bzw. write} access specifier of property TSend.

Jetzt meine Frage:
was hab ich falsch gemacht - und macht man das überhaupt so, oder würdet ihr die Klassen noch mal untereinander includen oder was weiß ich?
Danke im Vorraus... wtf wird V o r r a u s zensiert? OO

Tom

audacia

Dein Post ist ein wenig verwirrend. Bitte zeige mal die wichtigen Teile der Deklarationen aller beteiligten Klassen sowie den Kontext, in dem der Fehler auftritt.

un)skilled schrieb:

Danke im ... wtf wird V o r r a u s zensiert? OO

Bei mir wird "Voraus" nicht zensiert. Rate mal warum

akari

Hallo

Die Property-Deklaration verlangt nach Gettern und Settern, bzw. direkten Attributen.

private:
typedef void __fastcall (__closure *TSend)(TCustomWinSocket*, AnsiString, signed __int16);
typedef void __fastcall (__closure *TExecQuery)(AnsiString);
//...
public:
__property TExecQuery ExecQuery = {};
__property TSend Send = {read=iSend, write=iSend, default=NULL}; 
  // Property für die verwendung mit dem Objekt Inspektor
//...
TSend iSend; // interes Attribut

So kannst du nun der Klasse eine Eventmethode passendes Types an die Eigenschaft Send zuweisen und innerhalb von anderen Klassenmethoden aus aufrufen.

bis bald
akari

danke für die Antwort - ich habe aber immernoch das gleiche Problem...
wenn ich nun aber TSend FSend zusätzlich noch irgendwo hinschreib, dann kommt in der Funktionsdeklaration unten multiple deklaration of.... das stinkt bissl ^^
ansonsten danke schon mal - auch, wenn ich ne verstanden hab, was bei dir anders gewesen sein soll...

history.h

class history
{
 private:
         typedef void __fastcall (__closure *TSend)(TCustomWinSocket*, AnsiString, signed __int16);
         typedef void __fastcall (__closure *TStatus)(AnsiString);
         typedef void __fastcall (__closure *TGet)(AnsiString, signed __int16);
         typedef void __fastcall (__closure *TExecQuery)(AnsiString);
 public:
        __property TExecQuery ExecQuery = {};
        __property TSend Send = {read=FSend, write=FSend};
        __property TStatus Status = {read=FGet, write=FStatus};
        __property TGet Get = {read=FGet, write=FGet};
        void __fastcall FStatus (AnsiString value)
         {
///...
         };
        void __fastcall FGet (AnsiString value, signed __int16 from)
         {
///...
         };
        void __fastcall FSend (TCustomWinSocket* Socket, AnsiString value, signed __int16 to)
         {
///...
       };
};

akari

Hallo

Du hast den Sinn und Einsatz von Events noch nicht richtig verstanden.
Mal eine kurze Erläuterung : Es gibt zwei verschiedene Klassen. Eine Eventauslösende (E_Send) und eine Eventauffangende (E_Catch). Die Auslösende Klasse weiß wie ausgelöst wird, aber nicht wie der Event verarbeitet werden soll. Die Auffangende weiß nicht wie der Event ausgelöst wird, aber wie der Event verarbeitet werden soll. Also muß sich die Auffangende Klasse bei der Auslösenden Klasse registrieren. Das sieht mit den VCL-Properties und einem einfachem TNotifyEvent so aus

class E_Send : public TObject
{
  ...
  private :
    TNotifyEvent iEvent;
  public :
    __property TNotifyEvent Event = {read = iEvent, write = iEvent, default = NULL};
  ...
  DoSomething();  
};
E_Send::DoSomething()
{
  ...
  // Hier ist dir Stelle wo der Event ausgelöst wird, wenn ein Ziel registriert ist
  if (iEvent)
    iEvent(this);
}
...
class E_Catch : public TObject
{
  ...
  void RegisterTo(T_Send* Send);
  void __fastcall OnSomething(TObject* Sender);
};
...
void E_Catch::RegisterTo(T_Send* Sender)
{
  // Ziel registriert sich bei Sender
  Send->Event = OnSomething;
}

void __fastcall E_Catch::OnSomething(TObject* Sender)
{
  // Ziel kann auf den Event reagieren
  ShowMessage("Something is happended!");
}

Wie du siehst ist es elementarer Bestandteil des Eventprinzips das die Events-Eigenschaft (__property Event) und die Event-Methode (OnSomethong) in zwei verschiedenen Klassen stecken. Denn Events sind zum Kommunizieren zwischen verschiedenen Klassen, nicht innerhalb einer einzelnen Klasse! Selbst bei Ableitungen wäre der Gebrauch von virtuellen Methoden besser als Events.

Du solltest also erstmal nochmal gründlich überlegen was du eigentlich erreichen willst und was du dafür für welche Mittel brauchst.

bis bald
akari

Ja, ein Event ist hier schon richtig - danke Dir

Events &amp;&amp; E2347

Events && E2347