ISync is the central interface for all classes that control access to resources from multiple threads. It's a simple interface which has two basic use cases. The first case is to block indefinitely until a condition is met:

void ConcurrentRun(ISync lock) {
  lock.Acquire(); // block until condition met
  try {
    // ... access shared resources
  }
  finally {
    lock.Release();
  }
}

The other case is to specify a maximum amount of time to block before the condition is met:

void ImpatientConcurrentRun(ISync lock) {
  // block for at most 10 milliseconds for condition
  if ( lock.Attempt(10) ) {
    try {
      // ... access shared resources
    }
    finally {
      lock.Release();
    }
  } else {
    // complain of time out
  }
}

The SyncHolder class implements the System.IDisposable interface and so provides a way to use an ISync with the using C# keyword: the ISync will be automatically Acquired and then Released on exiting from the block.

This should simplify the programming model for code using (!) an ISync:

ISync sync = ...
...
using (new SyncHolder(sync))
  {
    // ... code to be executed
    // holding the ISync lock
  }
      

There is surely the timed version, a little more cumbersome as you must deal with timeouts:

ISync sync = ...
long msecs = 100;
...
// try to acquire the ISync for msecs milliseconds
try 
{
  using (new SyncHolder(sync, msecs))
  {
    // ... code to be executed
    // holding the ISync lock
  }
}    
catch (TimeoutException)
{
  // deal with failed lock acquisition
}

      

The Latch class implements the ISync interface and provides an implementation of a latch. A latch is a boolean condition that is set at most once, ever. Once a single release is issued, all acquires will pass. It is similar to a ManualResetEvent initialized unsignalled (Reset) and can only be Set(). A typical use is to act as a start signal for a group of worker threads.

class Boss {
  Latch _startPermit;

  void Worker() {
    // very slow worker initialization ...
    // ... attach to messaging system
    // ... connect to database
    _startPermit.Acquire();
    // ... use resources initialized in Mush
    // ... do real work
  }

  void Mush() {
    _startPermit = new Latch();
    for (int i=0; i<10; ++i) {
      new Thread(new ThreadStart(Worker)).Start();
    }
    // very slow main initialization ...
    // ... parse configuration
    // ... initialize other resources used by workers
    _startPermit.Release();
  }

}

The Semaphore class implements the ISync interface and provides an implementation of a semaphore. Conceptually, a semaphore maintains a set of permits. Each Acquire() blocks if necessary until a permit is available, and then takes it. Each Release() adds a permit. However, no actual permit objects are used; the Semaphore just keeps a count of the number available and acts accordingly. A typical use is to control access to a pool of shared objects.

class LimitedConcurrentUploader {
  // ensure we don't exceed maxUpload simultaneous uploads
  Semaphore _available;
  public LimitedConcurrentUploader(maxUploads) {
    _available = new Semaphore(maxUploads);
  }
  // no matter how many threads call this method no more
  // than maxUploads concurrent uploads will occur.
  public Upload(IDataTransfer upload) {
    _available.Acquire();
    try {
      upload.TransferData();
    }
    finally {
      _available.Release();
    }
  }
}