CODEWITHSUNDEEP
c#
Chris
Chris

Reputation: 470

Cancel request if taking to long to process

Hello is this possible in c#:

If I have a loop say: 

int x = 0;
for (int i = 0; i < 1000000; i++) {
  x++;
}

And it takes more than 1 second to complete, is it possible to kill the code and move on?

Upvotes: 4

Views: 2927

Answers (5)

StriplingWarrior
StriplingWarrior

Reputation: 156534

Yes, if you have the loop running in a different thread, you can abort that thread from a different thread. This would effectively kill the code you're running, and would work fine in the simplified example you've given. The following code demonstrates how you might do this:

void Main()
{
    double foo = 0;
    var thread = new Thread(() => foo = GetFoo());
    thread.Start();
    string message;
    if(thread.Join(1000))
    {
        message = foo.ToString();
    }
    else 
    {
        message = "Process took too long";
        thread.Abort();
    }
    message.Dump();
}

public double GetFoo() {
    double a = RandomProvider.Next(2, 5); 
    while (a == 3) { RandomProvider.Next(2, 5);} 
    double b = RandomProvider.Next(2, 5); 
    double c = b /a; 
    double e = RandomProvider.Next(8, 11); 
    while (e == 9) { RandomProvider.Next(8,11); } 
    double f = b / e;
    return f;
}

However, as you can see from Eric Lippert's comment (and others), aborting a thread is not very graceful (a.k.a. "pure evil"). If you were to have important things happening inside this loop, you could end up with data in an unstable state by forcing the thread abortion in the middle of the loop. So it is possible, but whether you want to use this approach will depend on what exactly you're doing in the loop.

So a better option would be to have your loops voluntarily decide to exit when they're told to (Updated 2015/11/5 to use newer TPL classes):

async void Main()
{
    try
    {
        var cancelTokenSource = new CancellationTokenSource(TimeSpan.FromMilliseconds(1000));
        var foo = await GetFooAsync(cancelTokenSource.Token);
        Console.WriteLine(foo);
    }
    catch (OperationCanceledException e)
    {
        Console.WriteLine("Process took too long");
    }
}

private Random RandomProvider = new Random();

public async Task<double> GetFooAsync(CancellationToken cancelToken) {
    double a = RandomProvider.Next(2, 5); 
    while (a == 3) 
    { 
        cancelToken.ThrowIfCancellationRequested();
        RandomProvider.Next(2, 5);
    } 
    double b = RandomProvider.Next(2, 5); 
    double c = b /a; 
    double e = RandomProvider.Next(8, 11); 
    while (e == 9) 
    { 
        cancelToken.ThrowIfCancellationRequested();
        RandomProvider.Next(8,11); 
    } 
    double f = b / e;
    return f;
}

This gives GetFooAsync an opportunity to catch on to the fact that it's supposed to exit soon, and make sure it gets into a stable state before giving up the ghost.

Upvotes: 5

Eric Lippert
Eric Lippert

Reputation: 660138

If you control the code that needs to be shut down then write logic into it that enables it to be shut down cleanly from another thread.

If you do not control the code that needs to be shut down then there are two scenarios. First, it is hostile to you and actively resisting your attempts to shut it down. That is a bad situation to be in. Ideally you should run that code in another process, not another thread, and destroy the process. A hostile thread has lots of tricks it can do to keep you from shutting it down.

Second, if it is not hostile and it can't be shut down cleanly then either it is badly designed, or it is buggy. Fix it. If you can't fix it, run it in another process, just like it was hostile.

The last thing you should do is abort the thread. Thread aborts are pure evil and should only be done as a last resort. The right thing to do is to design the code so that it can be cancelled cleanly and quickly.

More thoughts:

http://blogs.msdn.com/b/ericlippert/archive/2010/02/22/should-i-specify-a-timeout.aspx

Alternatively, you could go with a single-threaded approach. Break the work up into small chunks where the last thing each chunk of work does is enqueues the next chunk of work onto a work queue. You then sit in a loop, pulling work out of the queue and executing it. To stop early, just clear the queue. No need to go with a multithreaded approach if you don't need to.

Upvotes: 5

Luis Tellez
Luis Tellez

Reputation: 2983

If the problem is the number of iteration in the loop more than what you do inside the loop, then you can ask for save the time when the loop started, and see de diference betweeen each iteration ( or maybe %10, 20, 100) and cancel if the time you wanted to spend on that task is over.

Upvotes: 0

MusiGenesis
MusiGenesis

Reputation: 75296

You can achieve this in a simple way without mucking around with threading:

int x = 0;
int startTime = Environment.TickCount;
for (int i = 0; i < 1000000; i++)
{
    x++;
    int currentTime = Environment.TickCount;
    if ((currentTime - startTime) > 1000)
    {
        break;
    }
}

You can replace Environment.TickCount with a DateTime call or System.Diagnostics.Stopwatch if you like.

Upvotes: 1

oleksii
oleksii

Reputation: 35905

You can use background worker, this class supports cancellation

Upvotes: 0

Related Questions