.NET Reverse Semaphore?

Check out the CountdownLatch class in this magazine article.

Update: now covered by the framework since version 4.0, CountdownEvent class.

In .NET 4 there is a special type for that purpose CountdownEvent.

Or you can build similar thing yourself like this:

const int workItemsCount = 10;
// Set remaining work items count to initial work items count
int remainingWorkItems = workItemsCount;

using (var countDownEvent = new ManualResetEvent(false))
{
    for (int i = 0; i < workItemsCount; i++)
    {
        ThreadPool.QueueUserWorkItem(delegate
                                        {
                                            // Work item body
                                            // At the end signal event
                                            if (Interlocked.Decrement(ref remainingWorkItems) == 0)
                                                countDownEvent.Set();
                                        });
    }
    // Wait for all work items to complete
    countDownEvent.WaitOne();
}

Looks like System.Threading.WaitHandle.WaitAll might be a pretty good fit:

Waits for all the elements in the specified array to receive a signal.

Well... you can snatch all the semaphore counters on the main thread back in order to blocks when count is 0, rather than non-zero.

REVISED: Here I assumed 3 things:

• While the program is running, a new download job may start at any time.
• On exiting the program, there will be no more new downloads that needs taken care of.
• On exiting the program, you need to wait for the all the files to finish downloading

So here's my solution, revised:

Initializes the Semaphore with a large enough counter so you never hit the maximum (it could be simply 100 or just 10 depending on your situation):

var maxDownloads = 1000;
_semaphore = new Semaphore(0, maxDownloads);

Then on each downloads, begins with WaitOne() before starting the download so that in the event of program exiting, no downloads can start.

if (_semaphore.WaitOne())
    /* proceeds with downloads */
else
    /* we're terminating */

Then on download completion, release one counter (if we had acquired one):

finally { _semaphore.Release(1); }

And then on the "Exit" event, consume up all the counters on the Semaphore:

for (var i = 0; i < maxDownloads; i++)
    _semaphore.WaitOne();

// all downloads are finished by this point.

...

I had a similar issue where i needed to reset a server upon some event, but had to wait for all the open requests to finish before killing it.

I used the CountdownEvent class upon server start to initialize it with 1, and inside each request I do:

try
{
    counter.AddCount();
    //do request stuff
}
finally
{
    counter.Signal();
}

And upon receiving the ResetEvent i signal the counter once to eliminate the starting 1, and wait for live requests to signal they are done.

void OnResetEvent()
{
    counter.Signal();
    counter.Wait();
    ResetServer();
    //counter.Reset(); //if you want to reset everything again.
}

Basically you initialize the CountdownEvent with one, so that it's in a non signaled state, and with each AddCount call you are increasing the counter, and with each Signal call you are decreasing it, always staying above 1. In your wait thread you first signal it once to decrease the initial 1 value to 0, and if there are no threads running Wail() will immediately stop blocking, but if there are other threads that are still running, the wait thread will wait until they signal. Watch out, once the counter hits 0, all subsequent AddCount calls will throw an exception, you need to Reset the counter first.

For each thread you start Interlock.Increment a counter. And for each callback on thread finish, Decrement it.

Then do a loop with a Thread.Sleep(10) or something until the count reaches zero.