Question

Hello yeah I’m asking this question a second time, sorry about that but I don’t know how to bump previous question. I’ll explain more in depth my problem in a more completed example.

Instead of writing like 300+ Event classes in 300 class files which I may have to do if this doesn’t work, so they can do little timed jobs like this example job below in a server project.

What i’m trying to avoid is writing a bunch of classes and simply just write everything more compacted in structure of whatever i’m working on.

To sum it up, i’m mixing 90% functional programming and want to give some function some delayed timed event, without creating the new timed event in a separate class then running back and forth through the files looking how everything is linked up, but this way everything can be seen so you can find bugs and whatnot much faster as everything is right in front of you, kinda like writing loop code, but with delay.

All I have right now is one thread which processes events, deletes events which have been stopped, keeps re-running events which don’t stop after one cycle and of course waiting until some events can be ran.

If anyone knows a better way to do what i’m trying to do maybe some built-in C# Event system? Which is preferably simple.

class Event {
    private Action action;
    private bool stopped;

    public Event(long tick, Action action) {
        this.tick = tick;
        this.action = action;
        this.lastRun = Environment.TickCount;
    }

    public void stop() {
        stopped = true;
    }

    public bool canRun() { //blah ignore just showing what I plan to do
        if (stopped)
            return false;
         return (Environment.TickCount - lastRun) > tick;
    }

    public void run() {
          this.lastRun = Environment.TickCount;
        action();
    }

    //... other methods
}

 

class Test {
    string t;

    public void setT(string t) {
        this.t = t;
    }

    public void stuff() {
        Console.WriteLine(a);
    }
}

 

class ImportantWork {

    public static void Main(string[] args) {
        someDeepMethod();
    }

    void someDeepMethod() {
        Test t = new Test(); 
        t.setT("secondTime");

        //Here is where the problem occurs.

        Server.registerEvent(new Event(5000, () => {
                    this.stop();  //<-- Error how I call this from this new Event instance.
                    stop();  //<-- Also error
                    //Event.stop();  //<-- haha may work if it was static but thats stupid
                    t.stuff();
                    Console.WriteLine("thirdTime");
        }));

        t.setT("firstTime");
        t.stuff();
    }
}

Expected output:
firstTime
…waits 5 seconds…
secondTime
thirdTime

Answer 1

I don’t know how you’d be able to do that inline like that. Why can’t you use some kind of set-function and make it two lines?

MyEvent newEvent;
Server.registerEvent((newEvent = new MyEvent(5000)));
newEvent.setAction(() => {
                             newEvent.stop();
                             t.stuff();
                             Console.WriteLine("thirdTime");
                         });

It seems to me like there’s some kind of structural issue with your design. I’m assuming that the example you provided was not actually what you were working with, just a simple example to address the problem you’re having. If it is, however, the example you’re working with why don’t you just add a boolean flag in the constructor to tell the instance whether or not to call this.stop() on itself – instead of requiring it specified in the Action?

Best of luck!