LockCookie Structure

// The complete code is located in the ReaderWriterLock 
// class topic. 
using System;
using System.Threading;

public class Test
{
    // Declaring the ReaderWriterLock at the class level 
    // makes it visible to all threads. 
    static ReaderWriterLock rwl = new ReaderWriterLock();
    // For this example, the shared resource protected by the 
    // ReaderWriterLock is just an integer. 
    static int resource = 0;


...


// Shows how to request a reader lock, upgrade the 
// reader lock to the writer lock, and downgrade to a 
// reader lock again. 
static void UpgradeDowngrade(int timeOut)
{
    try
    {
        rwl.AcquireReaderLock(timeOut);
        try
        {
            // It is safe for this thread to read from 
            // the shared resource.
            Display("reads resource value " + resource); 
            Interlocked.Increment(ref reads);

            // If it is necessary to write to the resource, 
            // you must either release the reader lock and  
            // then request the writer lock, or upgrade the 
            // reader lock. Note that upgrading the reader lock 
            // puts the thread in the write queue, behind any 
            // other threads that might be waiting for the  
            // writer lock. 
            try
            {
                LockCookie lc = rwl.UpgradeToWriterLock(timeOut);
                try
                {
                    // It is safe for this thread to read or write 
                    // from the shared resource.
                    resource = rnd.Next(500);
                    Display("writes resource value " + resource);
                    Interlocked.Increment(ref writes);
                }        
                finally
                {
                    // Ensure that the lock is released.
                    rwl.DowngradeFromWriterLock(ref lc);
                }
            }
            catch (ApplicationException)
            {
                // The upgrade request timed out.
                Interlocked.Increment(ref writerTimeouts);
            }

            // When the lock has been downgraded, it is  
            // still safe to read from the resource.
            Display("reads resource value " + resource); 
            Interlocked.Increment(ref reads);
        }        
        finally
        {
            // Ensure that the lock is released.
            rwl.ReleaseReaderLock();
        }
    }
    catch (ApplicationException)
    {
        // The reader lock request timed out.
        Interlocked.Increment(ref readerTimeouts);
    }
}


...


}