[.NET 2.0] C# Nette class communicatie

[cyspoz]

Ik zit met een volgens mij simpel probleem maar kom er niet uit. Stel ik heb een class main die de hoofdclasse van mijn programma is. Ik heb een classe ComReader die gegevens van de parallele poort leest en als struct terug moet sturen naar de main classe. Wat ik wil is dat de classe ComReader eigenlijk een functie daarvoor aanroept in de classe main. Ik zou dit natuurlijk kunnen doen door de ComReader een referentie naar de classe main mee te geven en vervolgens main van een speciale publieke functie voorzien. Maar volgens mij is dit niet de manier zoals het moet. Hoe hoor je dit netjes te maken, wat voor mechanisme wordt hier doorgaans voor gebruikt?

code:

class Main
{
private:
  Main();
  ~Main();
public:
  void ComReaderHelpFunctie(struct myStruct);
}

class ComReader
{
public:
  ComReader(Main refMain)
  {
    //Lees wat van die comport doe dat in een struct en dan informatie naar main sturen
    refMain.ComReaderHelpFunctie(theMagicComStruct);
  }
  ~ComReader();
}

[whoami]

Waarom wil je dat die ComReader een functie aanroept in je main class ?

Je ComReader leest toch gewoon iets uit van de parralle poort, en stuurt die informatie gewoon naar je main. In je main kan je dan gewoon jouw method oproepen die iets doet met dat resultaat:

code:

byte[] result = ComReader.Read();
MyStruct s = DoSomething (result);

En als je dat echt niet wilt, en echt wil werken zoals je zegt, dan kan je met delegates werken.
Zorg ervoor dat die ComReader.Read method een argument meekrijgt van een bepaald delegate type, en zorg ervoor dat je in je main een method hebt die aan die delegate specificatie voldoet:

Stel, je hebt een delegate SomeDelegate

code:

public MyStruct SomeDelegate(byte[] bytes);

Je ComReader heeft een Read method die als argument een delegate neemt:

code:

public class ComReader
{
    public MyStruct Read( SomDelegate method )
    {
         ...
         byte[] result = ...
         return method(result);
    }
}

In je main heb je een method die voldoet aan de spec. van die delegate:

code:

public MyStruct ReadSomething(byte[] b)
{
    ....
}

En in je main roep je de ComReader aan, en geef je 'm die method mee:

code:

MyStruct s = ComReader.Read (new SomeDelegate(ReadSomething))

_{C# / pseudo code}

[Vedett.]

Doorgaans worden hier Events voor gebruikt. Ze roepen welliswaar niet expliciet een functie op in Main. Main moet er gewoon voor zorgen dat hij naar het event van ComReader moete luisteren.

Even met de losse hand

code:

public delegate void ComValueReceivedHandler(struct myvalue)

class ComReader{
   public event ComValueReceivedHandler ComValueReceived; //Hier moet denk ik ook de param achter)
}


class Main{

  ctor{
   ComReader comReader = new ComReader();
   comReader.ComValueReceived += new ComValueReceivedHandler(this.ProcessStruct);
  }

  private void ProcessStruct(struct myvalue){
    //processing gebeurt hier 
  }
}

Delegates als parameter doorgeven gaat idd ook. Maar als je met FxCop werkt komt die klagen. Blijkbaar is dat niet de ideale manier van werken.

[whoami]

Met events werken is misschien idd beter, maar misschien niet zo aangewezen hier; Dan zou ik er iig voor kiezen om die ComReader gewoon 'iets' te laten returnen, dat je dan zelf in die main behandeld.

Nuja, het hangt er eigenlijk een beetje van af wat je precies wilt doen / of hoe je het in z'n geheel ziet.

[cyspoz]

Ik ben vergeten aan te geven waarom het zo moet. Normaal zou je inderdaad zeggen dat je main class de informatie weer uit de classe in kwestie trekt middels een functie.
Probleem is alleen dat je niet weet waneer er weer nieuwe informatie is binnen gekomen over de com poort. En ik wil niet iets van een polling mechanisme dat Main ComReader gaat staan pollen. Het initiatief van een actie moet daarom vanuit de ComReader komen.
Ik zal me in iedergeval eens gaan verdiepen in Delegates en Events.

[whoami]

Dan is het idd beter dat je het met events doet. Je ComReader class kan een event raisen als er nieuwe informatie binnenkomt, en je main (de client) kan op dat event subscriben, en een method uitvoeren als dat event geraised is.

[cyspoz]

Ok dan ga ik het zo maken whoami. Bedankt.