Cancel request if taking to long to process

Question

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?

Answer 1

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.