ReaderWriterLock.UpgradeToWriterLock Method (Int32)

// 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);
    }
}


...


}