#if MONO using System;using System.Diagnostics;using System.Runtime;using System.Runtime.ConstrainedExecution;using System.Runtime.InteropServices;using System.Security.Permissions;using GSF; namespace System.Threading{    /// <summary>Provides a mutual exclusion lock primitive where a thread trying to acquire the lock waits in a loop repeatedly checking until the lock becomes available.</summary>    [DebuggerDisplay("IsHeld = {IsHeld}"), ComVisible(false)]    [HostProtection(SecurityAction.LinkDemand, Synchronization = true, ExternalThreading = true)]    public struct SpinLock    {        #region [ Members ]         // Fields        private int m_lockState;         #endregion         #region [ Properties ]         /// <summary>        /// Gets whether the lock is currently held by any thread.        /// </summary>        /// <returns>true if the lock is currently held by any thread; otherwise false.</returns>        public bool IsHeld        {            get            {                return this.m_lockState != 0;            }        }         #endregion         #region [ Methods ]         /// <summary>        /// Acquires the lock in a reliable manner, such that even if an exception occurs within the method call, <paramref name="lockTaken" /> can be examined reliably to determine whether the lock was acquired.        /// </summary>        /// <param name="lockTaken">True if the lock is acquired; otherwise, false.</param>        public void Enter(ref bool taken)        {            if (Interlocked.CompareExchange(ref m_lockState, 1, 0) != 0)            {                int count = 0;                 while (Interlocked.CompareExchange(ref m_lockState, 1, 0) != 0)                {                    count++;                     if (Environment.ProcessorCount > 1 && count <= 5)                        Thread.SpinWait(25);                    else                        Thread.Sleep(0);                }            }             taken = true;        }         /// <summary>        /// Attempts to acquire the lock in a reliable manner, such that even if an exception occurs within the method call, <paramref name="lockTaken" /> can be examined reliably to determine whether the lock was acquired.        /// </summary>        /// <param name="lockTaken">True if the lock is acquired; otherwise, false.</param>        public void TryEnter(ref bool lockTaken)        {            lockTaken = (Interlocked.CompareExchange(ref m_lockState, 1, 0) == 0);        }                /// <summary>        /// Attempts to acquire the lock in a reliable manner, such that even if an exception occurs within the method call, <paramref name="lockTaken" /> can be examined reliably to determine whether the lock was acquired.        /// </summary>        /// <param name="timeout">A <see cref="T:System.TimeSpan" /> that represents the number of milliseconds to wait, or a <see cref="T:System.TimeSpan" /> that represents -1 milliseconds to wait indefinitely.</param>        /// <param name="lockTaken">True if the lock is acquired; otherwise, false. <paramref name="lockTaken" /> must be initialized to false prior to calling this method.</param>        /// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="timeout" /> is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than <see cref="F:System.Int32.MaxValue" /> milliseconds.</exception>        public void TryEnter(TimeSpan timeout, ref bool lockTaken)        {            long num = (long)timeout.TotalMilliseconds;             if (num < -1L || num > 2147483647L)                throw new ArgumentOutOfRangeException("timeout", timeout, "timeout value is out of range");             TryEnter((int)timeout.TotalMilliseconds, ref lockTaken);        }         /// <summary>        /// Attempts to acquire the lock in a reliable manner, such that even if an exception occurs within the method call, <paramref name="lockTaken" /> can be examined reliably to determine whether the lock was acquired.        /// </summary>        /// <param name="millisecondsTimeout">The number of milliseconds to wait, or <see cref="F:System.Threading.Timeout.Infinite" /> (-1) to wait indefinitely.</param>        /// <param name="lockTaken">True if the lock is acquired; otherwise, false. <paramref name="lockTaken" /> must be initialized to false prior to calling this method.</param>        /// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="millisecondsTimeout" /> is a negative number other than -1, which represents an infinite time-out.</exception>        public void TryEnter(int millisecondsTimeout, ref bool lockTaken)        {            if (millisecondsTimeout < -1)                throw new ArgumentOutOfRangeException("millisecondsTimeout", "specified tiemout is a negative number other than -1.");             if (millisecondsTimeout == -1)            {                Enter(ref lockTaken);                return;            }             Ticks startTime = PrecisionTimer.UtcNow.Ticks;             TryEnter(ref lockTaken);             while (!lockTaken && (PrecisionTimer.UtcNow.Ticks - startTime).ToMilliseconds() < millisecondsTimeout)            {                Thread.Sleep(0);                TryEnter(ref lockTaken);            }        }         /// <summary>        /// Releases the lock.        /// </summary>        public void Exit()        {            this.m_lockState = 0;        }         #endregion    }} #endif