internal sealed class CatalogOrderSystem 
{
   // The gate used to protect access to the Catalog Order System’s data
   private ReaderWriterGate m_gate = new ReaderWriterGate();

   public void UpdateCatalogWS(CatalogEntry[] catalogEntries) 
   {
      ... // Perform any validation/pre-processing on catalogEntries...

      // Updating the catalog requires exclusive access to it.
      m_gate.QueueWrite(UpdateCatalog, catalogEntries);
   }

   // The code in this method has exclusive access to the catalog.
   private void UpdateCatalog(ReaderWriterGateReleaser r) 
   {
      CatalogEntry[] catalogEntries = (CatalogEntry[]) r.State;
      
      ... // Update the catalog with the new entries...
    } // When this method returns, exclusive access is relinquished.

   public void BuyCatalogProductsWS(CatIDAndQuantity[] items) 
   {
      // Buying products requires read access to the catalog.
      m_gate.QueueRead(BuyCatalogProducts, items);
   }

   // The code in this method has shared read access to the catalog.
   private void BuyCatalogProducts(ReaderWriterGateReleaser r) 
   {
      using (r) 
      {
         CatIDAndQuantity[] items = (CatIDAndQuantity[])r.State;
         foreach (CatIDAndQuantity item in items) 
         {
            ... // Process each catalog item to build customer’s order...
         }
      } // When r is Disposed, read access is relinquished.

      ... // Save customer’s order to database
      ... // Send customer e-mail confirming order
   }
}

public sealed class ReaderWriterGate 
{
   // Used for thread-safe access to other fields
   private ResourceLock m_syncLock = new MonitorResourceLock();

   // The current state of the gate; see the ReaderWriteGateStates enum
   private ReaderWriterGateStates m_state = ReaderWriterGateStates.Free;

   // The number of methods desiring shared access currently executing
   private Int32 m_numReaders = 0;

   // A FIFO queue of methods desiring exclusive access
   private Queue<ReaderWriterGateReleaser> m_qWriteRequests =
      new Queue<ReaderWriterGateReleaser>();

   // A FIFO queue of methods desiring shared access
   private Queue<ReaderWriterGateReleaser> m_qReadRequests =
      new Queue<ReaderWriterGateReleaser>();
}

private enum ReaderWriterGateStates 
{
   // No methods are desiring access
   Free,

   // One or more methods desiring shared access are executing
   // and no writer methods are queued up desiring access
   OwnedByReaders,

   // One or more methods desiring shared access are executing
   // and one or more writer methods are queued up desiring access
   OwnedByReadersAndWriterPending,

   // One method desiring exclusive access is executing
   OwnedByWriter
}

1. If m_state is Free
    1.1 Set m_state to OwnedByWriter
    1.2 Invoke callback method via ThreadPool’s QueueUserWorkItem
    1.3 Return to caller
2. If m_state is OwnedByReaders or OwnedByReadersAndWriterPending
    2.1 Set m_state to OwnedByReadersAndWriterPending
    2.2 Add ReaderWriterGateReleaser object to m_qWriteRequests
    2.3 Return to caller
3. If m_state is OwnedByWriter
    3.1 Do not change m_state
    3.2 Add ReaderWriterGateReleaser object to m_qWriteRequests
    3.3 Return to caller

1. If m_state is Free or OwnedByReaders
    1.1 Set m_state to OwnedByReaders
    1.2 Add 1 to m_numReaders
    1.3 Invoke callback method via ThreadPool’s QueueUserWorkItem
    1.4 Return to caller
2. If m_state is OwnedByWriter or OwnedByReadersAndWriterPending
    2.1 Do not change m_state
    2.2 Add ReaderWriterGateReleaser object to m_qReadRequests
    2.3 Return to caller

1. If a reader thread is releasing the gate, do steps 1.1 & 1.2;     
    else, go  to step #2
    1.1. Subtract 1 from m_numReaders
    1.2. If m_numReaders is > 0, return to caller; else, goto step #2
2. If m_qWriteRequests.Count > 0
    2.1. Set m_state to OwnedByWriter
    2.2. Invoke 1 writer callback method via ThreadPool’s
         QueueUserWorkItem
    2.3. Return to caller
3. If m_qReadRequests.Count > 0
    3.1. Set m_state to OwnedByReaders
    3.2. Set m_numReaders = m_qReadRequests.Count
    3.3. Invoke all reader callback methods via ThreadPool’s
         QueueUserWorkItem
    3.4. Return to caller
4. Set m_state to Free
5. Return to caller