CODEWITHSUNDEEP
c#.net-4.5.2
Ben Hoffman
Ben Hoffman

Reputation: 8259

Call a method and cancel it and return to the calling method if it takes too long

Is there a way in c# to call a method so that if the method takes to long to complete, the method will be canceled and it will return to the calling method? I think I can do this with threading but what if threading is not needed?

For reference, the method I may need to kill/stop/abort is calling the CorelDraw 15 API. This opens an instance of CorelDraw and I have received non-repeatable errors in this method. Meaning, I can process the same image twice and one time it will freeze or error and the other it will not.

The current solution to the issue I am using is to have a second application that does Process.Start(firstAppExecutablePath) and then checks a variable in a text file and if the variable doesn't change after 10 minutes, .Kill(); is called on the instance of the process. I would prefer to avoid this solution if possible as it seems clunky and prone to issues. Since it runs .Kill(); it is being very messy in how things close but generally does not cause an issue.

Upvotes: 3

Views: 446

Answers (2)

Cameron
Cameron

Reputation: 98746

Not built-in, no, since interrupting arbitrary code cannot be done safely (what if it's in the middle of calling a C library function (that doesn't support exceptions) which has just taken a global lock and needs to release it?).

But you can write such support yourself. I wouldn't add threads to the mix unless absolutely necessary, since they come with an entire new dimension of potential problems.

Example:

void Caller()
{
    int result;
    if (TryDoSomething(out result, 100)) {
        System.Console.WriteLine("Result: {0}", result);
    }
}

bool TryDoSomething(out int result, int timeoutMillis)
{
    var sw = Stopwatch.StartNew();
    result = 0x12345678;
    for (int i = 0; i != 100000000; ++i) {
        if (sw.ElapsedMilliseconds > timeoutMillis)
            return false;
        result += i / (result % 43) + (i % 19);
    }
    return true;
}

Upvotes: 1

Manfred Radlwimmer
Manfred Radlwimmer

Reputation: 13394

Threading is absolutely needed unless you are ok with checking the timeout from within the function - which probably you arn't. So here is a minimalistic approach with threads:

private static bool ExecuteWithTimeout(TimeSpan timeout, Action action)
{
    Thread x = new Thread(() => { action(); });
    x.Start();

    if (!x.Join(timeout))
    {
        x.Abort(); //Or Interrupt instead, if you use e.g. Thread.Sleep in your method
        return false;
    }

    return true;
}

Upvotes: 0

Related Questions