Updated AdoSecurityProvider to cache last known security context such that security system can initialize without database access.

ritchiecarroll committed 12 years ago

Commit d0046311 parent 1a8fe7514 files · +1042 −427Browse files

Showing the changes to Source/Libraries/GSF.Core/Threading/InterprocessReaderWriterLock.cs (1 of 14 files). Show all

Unified · Split

Source/Libraries/GSF.Core/Threading/InterprocessReaderWriterLock.cs+24−16

 namespace GSF.Threading
 {
     /// <summary>
-    /// Represents an interprocess reader/writer lock using <see cref="Semaphore"/> and <see cref="Mutex"/> native locking mechanisms.
+    /// Represents an inter-process reader/writer lock using <see cref="Semaphore"/> and <see cref="Mutex"/> native locking mechanisms.
     /// </summary>
     public class InterprocessReaderWriterLock : IDisposable
     {
         public const int DefaultMaximumConcurrentLocks = 10;
         // Fields
-        private Mutex m_semaphoreLock;          // Mutex used to synchronize access to Semaphore
+        private Mutex m_semaphoreLock;                  // Mutex used to synchronize access to Semaphore
-        private Semaphore m_concurrencyLock;    // Semaphore used for reader/writer lock on consumer object
+        private Semaphore m_concurrencyLock;            // Semaphore used for reader/writer lock on consumer object
-        private readonly int m_maximumConcurrentLocks;
+        private readonly int m_maximumConcurrentLocks;  // Maximum number of concurrent locks before waiting
         private bool m_disposed;
         #endregion
         /// Creates a new instance of the <see cref="InterprocessReaderWriterLock"/> associated with the specified
         /// <paramref name="name"/> that identifies a source object needing concurrency locking.
         /// </summary>
-        /// <param name="name">Identifiying name of source object needing concurrency locking (e.g., a path and file name).</param>
+        /// <param name="name">Identifying name of source object needing concurrency locking (e.g., a path and file name).</param>
         public InterprocessReaderWriterLock(string name)
             : this(name, DefaultMaximumConcurrentLocks)
         {
         /// Creates a new instance of the <see cref="InterprocessReaderWriterLock"/> associated with the specified
         /// <paramref name="name"/> that identifies a source object needing concurrency locking.
         /// </summary>
-        /// <param name="name">Identifiying name of source object needing concurrency locking (e.g., a path and file name).</param>
+        /// <param name="name">Identifying name of source object needing concurrency locking (e.g., a path and file name).</param>
         /// <param name="maximumConcurrentLocks">Maximum concurrent reader locks to allow.</param>
         /// <remarks>
         /// If more reader locks are requested than the <paramref name="maximumConcurrentLocks"/>, excess reader locks will simply
                     if (disposing)
                     {
                         if ((object)m_concurrencyLock != null)
+                        {
                             m_concurrencyLock.Close();
-                        m_concurrencyLock = null;
+                            m_concurrencyLock = null;
+                        }
                         if ((object)m_semaphoreLock != null)
+                        {
                             m_semaphoreLock.Close();
-                        m_semaphoreLock = null;
+                            m_semaphoreLock = null;
+                        }
                     }
                 }
                 finally
         /// Tries to enter the lock in read mode.
         /// </summary>
         /// <remarks>
-        /// Upon successful aquistion of a read lock, use the <c>finally</c> block of a <c>try/finally</c> statement to call <see cref="ExitReadLock"/>.
+        /// Upon successful acquisition of a read lock, use the <c>finally</c> block of a <c>try/finally</c> statement to call <see cref="ExitReadLock"/>.
         /// One <see cref="ExitReadLock"/> should be called for each <see cref="EnterReadLock"/> or <see cref="TryEnterReadLock"/>.
         /// </remarks>
         public void EnterReadLock()
         /// Tries to enter the lock in write mode.
         /// </summary>
         /// <remarks>
-        /// Upon successful aquistion of a write lock, use the <c>finally</c> block of a <c>try/finally</c> statement to call <see cref="ExitWriteLock"/>.
+        /// Upon successful acquisition of a write lock, use the <c>finally</c> block of a <c>try/finally</c> statement to call <see cref="ExitWriteLock"/>.
         /// One <see cref="ExitWriteLock"/> should be called for each <see cref="EnterWriteLock"/> or <see cref="TryEnterWriteLock"/>.
         /// </remarks>
         public void EnterWriteLock()
         /// Exits read mode and returns the prior read lock count.
         /// </summary>
         /// <remarks>
-        /// Upon successful aquistion of a read lock, use the <c>finally</c> block of a <c>try/finally</c> statement to call <see cref="ExitReadLock"/>.
+        /// Upon successful acquisition of a read lock, use the <c>finally</c> block of a <c>try/finally</c> statement to call <see cref="ExitReadLock"/>.
         /// One <see cref="ExitReadLock"/> should be called for each <see cref="EnterReadLock"/> or <see cref="TryEnterReadLock"/>.
         /// </remarks>
         public int ExitReadLock()
         /// Exits write mode.
         /// </summary>
         /// <remarks>
-        /// Upon successful aquistion of a write lock, use the <c>finally</c> block of a <c>try/finally</c> statement to call <see cref="ExitWriteLock"/>.
+        /// Upon successful acquisition of a write lock, use the <c>finally</c> block of a <c>try/finally</c> statement to call <see cref="ExitWriteLock"/>.
         /// One <see cref="ExitWriteLock"/> should be called for each <see cref="EnterWriteLock"/> or <see cref="TryEnterWriteLock"/>.
         /// </remarks>
         public void ExitWriteLock()
         /// <param name="millisecondsTimeout">The number of milliseconds to wait, or -1 (<see cref="Timeout.Infinite"/>) to wait indefinitely.</param>
         /// <returns><c>true</c> if the calling thread entered read mode, otherwise, <c>false</c>.</returns>
         /// <remarks>
-        /// Upon successful aquistion of a read lock, use the <c>finally</c> block of a <c>try/finally</c> statement to call <see cref="ExitReadLock"/>.
+        /// Upon successful acquisition of a read lock, use the <c>finally</c> block of a <c>try/finally</c> statement to call <see cref="ExitReadLock"/>.
         /// One <see cref="ExitReadLock"/> should be called for each <see cref="EnterReadLock"/> or <see cref="TryEnterReadLock"/>.
         /// </remarks>
         public bool TryEnterReadLock(int millisecondsTimeout)
         {
-            bool success = false;
+            bool success;
             try
             {
                 // The only way to get a semaphore slot count is to execute a successful wait and release.
                 startTime = DateTime.UtcNow.Ticks;
-                if (success = m_concurrencyLock.WaitOne(millisecondsTimeout))
+                success = m_concurrencyLock.WaitOne(millisecondsTimeout);
+                if (success)
                 {
                     int count = m_concurrencyLock.Release();
                     int adjustedTimeout = millisecondsTimeout;
                         if (adjustedTimeout < 0)
                             adjustedTimeout = 0;
-                        if (success = m_concurrencyLock.WaitOne(adjustedTimeout))
+                        success = m_concurrencyLock.WaitOne(adjustedTimeout);
+                        if (success)
                             count = m_concurrencyLock.Release();
                     }
                 }

Updated AdoSecurityProvider to cache last known security context such that security system can initialize without database access.

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code