CODEWITHSUNDEEP
c#parallel-processingtask
LaurentH
LaurentH

Reputation: 301

c# do the equivalent of restarting a Task with some parameter

The main idea here is to fetch some data from somewhere, when it's fetched start writing it, and then prepare the next batch of data to be written, while waiting for the previous write to be complete.

I know that a Task cannot be restarted or reused (nor should it be), although I am trying to find a way to do something like this :

//The "WriteTargetData" method should take the "data" variable 
//created in the loop below as a parameter
//WriteData basically do a shedload of mongodb upserts in a separate thread,
//it takes approx. 20-30 secs to run
var task = new Task(() => WriteData(somedata));

//GetData also takes some time.
foreach (var data in queries.Select(GetData))
{
    if (task.Status != TaskStatus.Running)
    {
        //start task with "data" as a parameter
        //continue the loop to prepare the next batch of data to be written
    }
    else
    {
        //wait for task to be completed
        //"restart" task
        //continue the loop to prepare the next batch of data to be written
    }
}

Any suggestion appreciated ! Thanks. I don't necessarily want to use Task, I just think it might be the way to go.

Upvotes: 1

Views: 228

Answers (4)

Tony Vitabile
Tony Vitabile

Reputation: 8614

You can use a thread and an AutoResetEvent. I have code like this for several different threads in my program:

These are variable declarations that belong to the main program.

public AutoResetEvent StartTask = new AutoResetEvent(false);
public bool IsStopping = false;
public Thread RepeatingTaskThread;

Somewhere in your initialization code:

RepeatingTaskThread = new Thread( new ThreadStart( RepeatingTaskProcessor ) ) { IsBackground = true; };
RepeatingTaskThread.Start();

Then the method that runs the repeating task would look something like this:

private void RepeatingTaskProcessor() {
    // Keep looping until the program is going down.
    while (!IsStopping) {
        // Wait to receive notification that there's something to process.
        StartTask.WaitOne();

        // Exit if the program is stopping now.
        if (IsStopping) return;

        // Execute your task
        PerformTask();
    }
}

If there are several different tasks you want to run, you can add a variable that would indicate which one to process and modify the logic in PerformTask to pick which one to run.

I know that it doesn't use the Task class, but there's more than one way to skin a cat & this will work.

Upvotes: 0

fooser
fooser

Reputation: 862

This may be over simplifying your requirements, but would simply "waiting" for the previous task to complete work for you? You can use Task.WaitAny and Task.WaitAll to wait for previous operations to complete.

pseudo code:

    // Method that makes calls to fetch and write data.
    public async Task DoStuff()
    {
        Task currTask = null;

        object somedata = await FetchData();

        while (somedata != null)
        {
            // Wait for previous task.
            if (currTask != null)
                Task.WaitAny(currTask);

            currTask = WriteData(somedata);

            somedata = await FetchData();
        }
    }

    // Whatever method fetches data.
    public Task<object> FetchData()
    {
        var data = new object();

        return Task.FromResult(data);
    }

    // Whatever method writes data.
    public Task WriteData(object somedata)
    {
        return Task.Factory.StartNew(() => { /* write data */});
    }

Upvotes: 1

KitAndKat
KitAndKat

Reputation: 952

something like ?

      public void Do()
        {
            var task = StartTask(500);
            var array = new[] {1000, 2000, 3000};

        foreach (var data in array)
        {
            if (task.IsCompleted)
            {
                task = StartTask(data);
            }
            else
            {
                task.Wait();
                task = StartTask(data);
            }
        }
    }

    private Task StartTask(int data)
    {
        var task = new Task(DoSmth, data);
        task.Start();
        return task;
    }

    private void DoSmth(object time)
    {
        Thread.Sleep((int) time);
    }

Upvotes: 0

Venson
Venson

Reputation: 1870

The Task class is not designed to be restarted. so you Need to create a new task and run the body with the same Parameters. Next i do not see where you start the task with the WriteData function in its body. That will property Eliminate the call of if (task.Status != TaskStatus.Running) There are AFAIK only the class Task and Thread where task is only the abstraction of an action that will be scheduled with the TaskScheduler and executed in different threads ( when we talking about the Common task Scheduler, the one you get when you call TaskFactory.Scheduler ) and the Number of the Threads are equal to the number of Processor Cores.

To you Business App. Why do you wait for the execution of WriteData? Would it be not a lot more easy to gater all data and than submit them into one big Write?

Upvotes: 0

Related Questions