QueueUserWorkItem with delegate does not work, but WaitCallBack does work

c#, delegates, multithreading

Solution

The answers to both of your question are related to the scope of the closure when you create the anonymous method.

When you do this:

// Closure for anonymous function call begins here.
for (int i = 0; i < 10; ++i)
{
    // i is captured
    ThreadPool.QueueUserWorkItem(delegate { DoWork("closure", i); });
}

You're capturing `i` across the entire loop. That means that you queue up your ten threads very quickly, and by the time they start, the closure has captured `i` to be 10.

To get around this, you reduce the scope of the closure, by introducing a variable inside the loop, like so:

for (int i = 0; i < 10; ++i)
{
    // Closure extends to here.
    var copy = i;

    // **copy** is captured
    ThreadPool.QueueUserWorkItem(delegate { DoWork("closure", copy); });
}

Here, the closure doesn't extend beyond the loop, but just to the value inside.

That said, the second call to the `QueueUserWorkItem` produces the desired result because you've created the `Tuple<T1, T2>` at the time that the delegate is being queued up, the value is fixed at that point.

Note that in C# 5.0, the behavior for `foreach` was changed because it happens so often (where the closure closes over the loop) and causes a number of people a lot of headaches (but not `for` like you are using).

If you want to take advantage of that fact, you can call the `Range` method on the `Enumerable` class to use `foreach`:

foreach (int i in Enumerable.Range(0, 10))
{
    // Closure for anonymous function call begins here.
    ThreadPool.QueueUserWorkItem(delegate { DoWork("closure", i); });
}

Problem

Original source

Related problems

• What's the difference between QueueUserWorkItem() and BeginInvoke(), for performing an asynchronous activity with no return types needed