Thanks. This article is very useful.

I am getting compile time error for void return methods:

public static void Limex(Action A, int Timeout, out bool Completed)
{
Limex(new Func(() => { A(); return null; }), Timeout, out Completed);
}

I have added above function. Here Func is generating error. Below is the compile time error message:

Using the generic type ‘System.Func’ requires 10 type arguments

Am I doing anything wrong here?

Can you please look into this?

This situation is familiar to me. Is ready to help.

The possession of unlimited power will make a despot of almost any man.

Buy-buy!

public static void Limex(Action A, int Timeout, out bool Completed)
{
Limex(new Func(() => { A(); return null; }), Timeout, out Completed);
}

and call it as following :

static void Test()
{
Thread.Sleep(5000);
}

Limex(Test, 100, out Completed);

private static T InvokeWithTimeout(Func operation)
{
T result = default(T);
if (timeout == 0)
{
result = operation.Invoke();
}
else
{
var async = operation.BeginInvoke(AsyncCleanup,operation);
if (async.AsyncWaitHandle.WaitOne(timeout))
{
result = operation.EndInvoke(async);
}
}
return result;
}

private static void AsyncCleanup(IAsyncResult result)
{
var operation = result.AsyncState as Func;
if (operation != null)
{
operation.EndInvoke(result);
}
}

Thanks for a great discussion and i hope to see you in my future posts.

Thread t = null;
Action action = () =>
{
t = Thread.CurrentThread;
F();
};

Then you call BeginInvoke on action instead of F. The action delegate will execute on the threadpool, so in that context Thread.CurrentThread will be your threadpool thread. If WaitOne returns false, you call t.Abort(). This is nasty for reasons I mentioned earlier, with the added problem that it gradually wrecks the threadpool.

I’m not necessarily arguing that my way is better, just an alternative. Fundamentally, there is no first-class language support for what you’re trying to do, so any solution is going to be hacky in some respect. If your solution is working for you, don’t sweat it – just be aware of the risks, particularly with Thread.Abort().

        // This is your solution
        public static T SafeLimex<T>(Func<T> F, int Timeout, out bool Completed)
        {
            var iar = F.BeginInvoke(null, new object());
            if (iar.AsyncWaitHandle.WaitOne(Timeout))
            {
                Completed = true;
                return F.EndInvoke(iar);
            }

            Completed = false;
            return default(T);
        }

Now let’s try to execute the next code :

            for (int n = 0; n < 100; n++)
            {
                var r = SafeLimex(() => {
                    Console.WriteLine("\n\rThread : " + Thread.CurrentThread.ManagedThreadId);
                    Thread.Sleep(100);
                    for (int i = 0; i < 1000; i++) { Console.Write(i); }
                    return "result";
                }, 120, out Finished);
                Console.WriteLine("\n\r" + "Result : " + r + ", Finished : " + Finished);
            }

You will get something like this :

Thread : 7
0123456789101….454647484950…561
Result : , Finished : False
5625635645……………………………….601
Thread : 11
602603604…………………………………698
Result : , Finished : False
699……………………………………………999

Let’s say you are executing some loop with 100ms timeout – you will get the result after 100ms (null or not), but the loop will continue executing till it stops (which is very bad and dangerous)