Run Once Code: Beyond Boolean?

Question

I'm struggling for a pattern here. I have quite a few tasks that need to be run, but only need to be run once if they haven't been run before. Everything right now is handled by if/then, booleans and a hashtable. There are also nested children of the same effect (if/then, boolean) so their parent if/then, boolean isn't set to true until the very end.

In .NET, is there some kind of code pattern or class for this that makes it simplier/clearer/less code, or am I over-thinking it and this is exactly the way needs to be done?

_{P.S. feel free to add better tags to this post, I wouldn't know what to add to make it more descriptive if there is a term out there}

Answer 1

If you're using .NET 4.0, the Lazy<T> generic might be the solution to what you're describing, because it evaluates its value at most once.

I'm not sure I exactly understand your use case, but there's no reason you couldn't nest Lazys together to accomplish the nested children issue.

Answer 2

I'm not exactly sure what you're talking about, but a helpful pattern for complex chained logic is the rules engine. They're really simple to code, and can be driven by simple truth tables, which are either compiled into your code or stored as data.

Answer 3

Create a private static variable, create a read only property to check for null on the private variable, if the variable is null instantiate/initialize and just return the private variable value. In your implementation code reference the property, never the private variable.

Answer 4

I don't know how your tasks are coded, but it seems that they could be encapsulated in commands, which would then be put in a queue, or some other data structure. Once they are dequeued, their logic is checked. If they need to run, they are executed, and they're not put back in the queue. If their logic says that they shouldn't run, they're just put back in the queue to be able to run later.

Your interface would be something like:

public interface ITaskSink {
  void AddTask(ICommandTask task);
}

public interface ICommandTask {
  bool ShouldRun();
  void Run(ITaskSink sink);
}

Tasks could also be able to add other tasks to the data structure (so Run takes an ITaskSink as a parameter), covering your subtask creation requirement. A task could even add itself back to the sink, obviating the need for the ShouldRun method and simplifying your task processor class.