Home/ Questions/Q 7431731
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-29T09:20:29+00:00

I have a C# service application which interacts with a database. It was recently

  • 0

I have a C# service application which interacts with a database. It was recently migrated from .NET 2.0 to .NET 4.0 so there are plenty of new tools we could use.

I’m looking for pointers to programming approaches or tools/libraries to handle defining tasks, configuring which tasks they depend on, queueing, prioritizing, cancelling, etc.

There are various types of services:

  • Data (for retrieving and updating)
  • Calculation (populate some table with the results of a calculation on the data)
  • Reporting

These services often depend on one another and are triggered on demand, i.e., a Reporting task, will probably have code within it such as 

if (IsSomeDependentCalculationRequired())
    PerformDependentCalculation();  // which may trigger further calculations
GenerateRequestedReport();

Also, any Data modification is likely to set the Required flag on some of the Calculation or Reporting services, (so the report could be out of date before it’s finished generating). The tasks vary in length from a few seconds to a couple of minutes and are performed within transactions.

This has worked OK up until now, but it is not scaling well. There are fundamental design problems and I am looking to rewrite this part of the code. For instance, if two users request the same report at similar times, the dependent tasks will be executed twice. Also, there’s currently no way to cancel a task in progress. It’s hard to maintain the dependent tasks, etc..

I’m NOT looking for suggestions on how to implement a fix. Rather I’m looking for pointers to what tools/libraries I would be using for this sort of requirement if I were starting in .NET 4 from scratch. Would this be a good candidate for Windows Workflow? Is this what Futures are for? Are there any other libraries I should look at or books or blog posts I should read?

Edit: What about Rx Reactive Extensions?

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    I don’t think your requirements fit into any of the built-in stuff. Your requirements are too specific for that.

    I’d recommend that you build a task queueing infrastructure around a SQL database. Your tasks are pretty long-running (seconds) so you don’t need particularly high throughput in the task scheduler. This means you won’t encounter performance hurdles. It will actually be a pretty manageable task from a programming perspective.

    Probably you should build a windows service or some other process that is continuously polling the database for new tasks or requests. This service can then enforce arbitrary rules on the requested tasks. For example it can detect that a reporting task is already running and not schedule a new computation.

    My main point is that your requirements are that specific that you need to use C# code to encode them. You cannot make an existing tool fit your needs. You need the turing completeness of a programming language to do this yourself.

    Edit: You should probably separate a task-request from a task-execution. This allows multiple parties to request a refresh of some reports while at the same time only one actual computation is running. Once this single computation is completed all task-requests are marked as completed. When a request is cancelled the execution does not need to be cancelled. Only when the last request is cancelled the task-execution is cancelled as well.

    Edit 2: I don’t think workflows are the solution. Workflows usually operate separately from each other. But you don’t want that. You want to have rules which span multiple tasks/workflows. You would be working against the system with a workflow based model.

    Edit 3: A few words about the TPL (Task Parallel Library). You mentioned it (“Futures”). If you want some inspiration on how tasks could work together, how dependencies could be created and how tasks could be composed, look at the Task Parallel Library (in particular the Task and TaskFactory classes). You will find some nice design patterns there because it is very well designed. Here is how you model a sequence of tasks: You call Task.ContinueWith which will register a continuation function as a new task. Here is how you model dependencies: TaskFactory.WhenAll(Task[]) starts a task that only runs when all its input tasks are completed.

    BUT: The TPL itself is probably not well suited for you because its task cannot be saved to disk. When you reboot your server or deploy new code, all existing tasks are being cancelled and the process aborted. This is likely to be unacceptable. Please just use the TPL as inspiration. Learn from it what a “task/future” is and how they can be composed. Then implement your own form of tasks.

    Does this help?

    • 0