[C#] Timers in an Object in a List<Object>

[Joshuatree]

Hallo ik ben proberen om een lijst van Objecten te maken die in zich een Timer hebben.
Nu wil ik dat als aan een bepaalde voorwaarde niet wordt voldaan in het hoofprogramma een Method wordt
aan geroepen.

Ik ben al alles aan het lezen over Delegates e.d. maar soms is lezen alleen niet genoeg

Ik heb Bomb

C#:

class Bomb {

      private Timer _tickTack = new Timer();
      
      public bool On = false;
      public Timer TickTack {
         get {
            return _tickTack;
         }
         set {
            _tickTack = value;
         }
      }
      
      private int _milliSeconds;
      public int MilliSeconds {
         get {
            return _milliSeconds;
         }
         set {
            _milliSeconds = value;
         }
      }

      private int _timeBombId;
      public int TimeBombId {
         get {
            return _timeBombId;
         }
         set {
            _timeBombId = value;
         }
      }

      public Bomb(int MilliSeconds, int aTimeBombId) {
         this.MilliSeconds = MilliSeconds;
         TimeBombId = aTimeBombId;
         TickTack.Elapsed += new ElapsedEventHandler(Explode);
         TickTack.Interval = this.MilliSeconds;
         On = true;
         TickTack.Start();
      }

      void Explode(object sender, ElapsedEventArgs e) {
        if(On == true){
            //Meld dit in aan roepende class; ????
        }
        else{
            //Log of .... whatever
        }
      
         //??
      }
   }
   
   Aanroep
      class Program {
      
      static void Main(string[] args) {

         List<Bomb> bombs = new List<Bomb>();
         for (int i = 1; 1 < 11; i++) {
            bombs.Add(new Bomb(i * 1000, i));
         }
         
         ....
         ....
      }
      
      
      public void BombFromListExploded(Object sender, EventArgs args){
        Consolse.WriteLine((Bomb)sender.TimeBombId);
        etc...
      }
      

Hoe kan ik in de aanroepende class gebruik maken van de Explode om bijvoorbeeld een mail of sms te sturen
met de TimeBomId.
Ik wil namelijk niet dat deze functionaliteit in de Bomb zit.

Alvast bedankt.

[FireDrunk]

Kun je niet beter een event maken? Dat lijkt me veel makkelijker....

C#:

public class Bomb
{
 event BombExploded
}

public class Explode
{
public void BombExploded(Bomb bomb)
{

}
}

public void Main
{
private void Main()
{
 Bomb bomb = new Bomb();
 bomb.BombExploded += CreateExplosion(bom);
}

private void CreateExplosion(Bomb bomb)
{
new Explode().BombExploded(bomb);
}
}

** let op, pseudo code **

Wel even Event afmaken natuurlijk

Plus ik zou Explode los van Bomb maken, of een overerving maken...
Explode is namelijk een effect, geen basisklasse om het zo maar te zeggen...

Je zou kunnen doen:

C#:

class Bomb
{

}

class ExplodingBomb : Bomb
{

}

class ExplodedBomb : Bomb
{

}

Dat lijkt mij de mooiste oplossing...

Leesvoer: http://dotnet.zcu.cz/NET_2006/Papers_2006/short/B31-full.pdf

[ Voor 29% gewijzigd door FireDrunk op 11-03-2011 11:48 ]

[Verwijderd]

FireDrunk schreef op vrijdag 11 maart 2011 @ 11:44:
[...]
Plus ik zou Explode los van Bomb maken, of een overerving maken...
Explode is namelijk een effect, geen basisklasse om het zo maar te zeggen...

Je zou kunnen doen:

C#:

class Bomb
{

}

class ExplodingBomb : Bomb
{

}

class ExplodedBomb : Bomb
{

}

Dat lijkt mij de mooiste oplossing...

Leesvoer: http://dotnet.zcu.cz/NET_2006/Papers_2006/short/B31-full.pdf

Wut? Explode is state informatie van een bom wat geencapsuleerd wordt door bom. Dus 1 class bom met de mogelijkheid om te checken of deze al geexplodeerd is.

Edit: note to self volgende keer eerst lezen. Wanneer je het als finite state machine implementeert zoals het in het paper beschreven is kan het netter zijn, of het nu zo handig is...

[ Voor 12% gewijzigd door Verwijderd op 11-03-2011 13:14 . Reden: beetje nuance kan nooit kwaad... ]

[BurningSheep]

FireDrunk schreef op vrijdag 11 maart 2011 @ 11:44:
Je zou kunnen doen:

C#:

class Bomb
{

}

class ExplodingBomb : Bomb
{

}

class ExplodedBomb : Bomb
{

}

Dat lijkt mij de mooiste oplossing...

Volgens mij zet dit de deur open naar hele rare bugs. Je moet immers steeds een nieuw object aanmaken als de toestand van je object verandert.

Liever zou ik kiezen voor het state design pattern:

http://www.dofactory.com/Patterns/PatternState.aspx

[ Voor 36% gewijzigd door BurningSheep op 11-03-2011 14:07 ]

[FireDrunk]

Zoals mijn referentie ook aangeeft is dit een vervoeging (of hoe je het ook mag noemen) op het gewone State pattern. Het vangt door middel van interfaces af dat een object intact blijft bij het casten naar een andere state (en dus een ander object en dus een andere implementatie)

Voordeel is dat je heel makkelijk logica kan toevoegen en verwijderen zonder dat je het basis object hoeft te veranderen.

Verwijderd schreef op vrijdag 11 maart 2011 @ 13:06:
Wut? Explode is state informatie van een bom wat geencapsuleerd wordt door bom. Dus 1 class bom met de mogelijkheid om te checken of deze al geexplodeerd is.

Wat jij zegt klopt wel, maar wat nou als je een Bom hebt met 1000 verschillende states (overdreven natuurlijk, maar stel...) Dan wil je dat gedrag loskoppelen

En aangezien ik niet weet wat of de TS dit nog verder wil uitbereiden, is het misschien makkelijk om hem op voorhand goede design patterns aan te leveren. Het gewone State Design Pattern is ook zeker goed!

Laat TS maar lekker zelf knutselen wat hij het fijnst vind

[ Voor 46% gewijzigd door FireDrunk op 11-03-2011 15:54 ]

[JochemK]

Waarom niet gewoon met een afgeleide van EventArgs:

C#:

public class Bomb
{
    public event EventHandler<BombExplodedEventArgs> Exploded;
    protected void Explode()
    {
        if (Exploded != null) 
        {
            Exploded(this, new BombExplodedEventArgs(this));
        }
    }
}

public class BombExplodedEventArgs : EventArgs
{
    public BombExplodedEventArgs(Bomb b)
    {
        explodedBomb = b; 
    }

    public Bomb explodedBomb { get; private set; }
}

[Joshuatree]

Sorry voor mijn late reactie maar bedankt voor jullie reacties

Ik ben vrijdag natuurlijk nog even door gegaan met knutselen en had inderdaad een oplossing gevonden
(die ik ook nog moet leren begrijpen) met EventArgs.

Ik heb de code nu niet bij de hand maar zal deze morgen plaatsen. Dit is nog niet het eindresultaat.
Eerst ga ik mijn gemak even de links doorlezen die jullie hebben gegeven waarschijnlijk kom ik tot heel andere inzichten..

[Joshuatree]

Zoals beloofd...

Toegevoegd de Class

C#:

public class BombExplodeEventArgs : EventArgs {

      public Bomb explodedBomb {
         get;
         private set;
      }

      public BombExplodeEventArgs(Bomb aBomb) {
         explodedBomb = aBomb;
      }
   }

De Class Bomb met een delegate...

C#:

public delegate void BombExplodedEventHandler(object sender, BombExplodeEventArgs e);

   public class Bomb {

      public event BombExplodedEventHandler Exploded;

      private bool _on;
      public bool On {
         get {
            return _on;
         }
         set {
            _on = value;
         }
      }

      private Timer _tickTack = new Timer();
      public Timer TickTack {
         get {
            return _tickTack;
         }
         set {
            _tickTack = value;
         }
      }

      private int _milliSeconds;
      public int MilliSeconds {
         get {
            return _milliSeconds;
         }
         set {
            _milliSeconds = value;
         }
      }

      private int _timeBombId;
      public int TimeBombId {
         get {
            return _timeBombId;
         }
         set {
            _timeBombId = value;
         }
      }

      public Bomb(int MilliSeconds, int aTimeBombId) {
         this.MilliSeconds = MilliSeconds;
         TimeBombId = aTimeBombId;
         TickTack.Elapsed += new ElapsedEventHandler(Explode);
         TickTack.Interval = this.MilliSeconds;
         On = true;
         TickTack.Start();
      }

      protected virtual void Explode(object sender, EventArgs e) {
         BombExplodeEventArgs bombExplodeEventArgs = new BombExplodeEventArgs(this);
         if (Exploded != null)
            Exploded(this, bombExplodeEventArgs);
      }
   }

Aanroep in de hoofd class

C#:

         List<Bomb> bombs = new List<Bomb>();
         for (int i = 1; i < 11; i++) {
            Bomb bomb = new Bomb(i*1000, i);
            bomb.Exploded += new BombExplodedEventHandler(Exploded);
            bombs.Add(bomb);
         }

         System.Threading.Thread.Sleep(30000);


         foreach (Bomb bomb in bombs) {
            if (bomb.TimeBombId % 2 == 0) {
               bomb.On = false;
            }
         }
....
...

     static void Exploded(object sender, BombExplodeEventArgs e) {
         if (((Bomb)sender).On == true) {
            Console.WriteLine("Exploded {0}: ",((Bomb)sender).TimeBombId);
         }
         else {
            Console.WriteLine("Disarmed {0}: ", ((Bomb)sender).TimeBombId);
         }
      }

Klopt natuurlijk niet helemaal met dat Exploded en Disarmed.

Met deze class wil ik gaan bijhouden of een file (met fileID) binnen 30 seconden een traject heeft doorlopen.

Dan ga ik nu nog het State pattern bestuderen en misschien gaat deze oplossing wel exploded en plaatsmaken voor een nieuwe..

[Hoogie2004]

Mag ik vragen wat voor nut het heeft om een eigen implementatie te maken van BombExplodedEventArgs. De enige info die je erinstopt gebruik je niet, dus volgens mij voldoet een normale EventArgs ook?

Je zou

code:

((Bomb)sender)

ook kunnen schrijven als

code:

e.explodedBomb

Dan heeft het nieuwe EventArgs object wel zin (echter is hier sender beter voor geschikt indien de bomb die het event triggert ook degene is die explodeert)

[ Voor 36% gewijzigd door Hoogie2004 op 14-03-2011 10:15 ]

[Joshuatree]

Zoals ik al aan gaf moet ik nog doorkrijgen waar ik mee bezig ben. Dus bedankt voor je tip

De code in de aan roepende class:

C#:

List<Bomb> bombs = new List<Bomb>();
         for (int i = 1; i < 4; i++) {
            Bomb bomb = new Bomb(1000, i);
            bomb.Exploded += new EventHandler(Exploded);
            bombs.Add(bomb);
         }
   ......

     static void Exploded(object sender, EventArgs e) {
         if (((Bomb)sender).On == true) {
            Console.WriteLine("Exploded {0}: ", ((Bomb)sender).TimeBombId);
         }
         else {
            Console.WriteLine("Disarmed {0}: ", ((Bomb)sender).TimeBombId);
         }
      }

De Bomb class heb ik aangepast zoals je zei (tenminste zoals ik het begreep )

C#:

      public delegate void EventHandler(object sender, EventArgs e);

      public class Bomb {
          public event EventHandler Exploded;
      .....

      protected virtual void Explode(object sender, EventArgs e) {
         EventArgs eventArgs = new EventArgs();
         if (Exploded != null)
            Exploded(this, e);
      }
     ....

Thanx!