We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Threading \ _TimerCallback

SSCLI
  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. /*=============================================================================
  16. **
  17. ** Class: TimerQueue
  18. **
  19. **
  20. ** Purpose: Class for creating and managing a threadpool
  21. **
  22. **
  23. =============================================================================*/
  25. namespace System.Threading
  26. {
  27.     using System.Threading;
  28.     using System;
  29.     using System.Security;
  30.     using System.Security.Permissions;
  31.     using Microsoft.Win32;
  32.     using System.Runtime.CompilerServices;
  33.     using System.Runtime.InteropServices;
  34.     using System.Runtime.ConstrainedExecution;
  35.    
  36.     internal class _TimerCallback
  37.     {
  38.         TimerCallback _timerCallback;
  39.         ExecutionContext _executionContext;
  40.         object _state;
  41.         static internal ContextCallback _ccb = new ContextCallback(TimerCallback_Context);
  42.         static internal void TimerCallback_Context(object state)
  43.         {
  44.             _TimerCallback helper = (_TimerCallback)state;
  45.             helper._timerCallback(helper._state);
  46.            
  47.         }
  48.        
  49.         internal _TimerCallback(TimerCallback timerCallback, object state, ref StackCrawlMark stackMark)
  50.         {
  51.             _timerCallback = timerCallback;
  52.             _state = state;
  53.             if (!ExecutionContext.IsFlowSuppressed()) {
  54.                 _executionContext = ExecutionContext.Capture(ref stackMark);
  55.                 ExecutionContext.ClearSyncContext(_executionContext);
  56.             }
  57.         }
  58.        
  59.         // call back helper
  60.         static internal void PerformTimerCallback(object state)
  61.         {
  62.             _TimerCallback helper = (_TimerCallback)state;
  63.            
  64.             BCLDebug.Assert(helper != null, "Null state passed to PerformTimerCallback!");
  65.             // call directly if EC flow is suppressed
  66.             if (helper._executionContext == null) {
  67.                 TimerCallback callback = helper._timerCallback;
  68.                 callback(helper._state);
  69.             }
  70.             else {
  71.                 // From this point on we can use useExecutionContext for this callback
  72.                 ExecutionContext.Run(helper._executionContext.CreateCopy(), _ccb, helper);
  73.             }
  74.         }
  75.     }
  76.    
  77.     [System.Runtime.InteropServices.ComVisible(true)]
  78.     public delegate void TimerCallback(object state);
  79.    
  80.     [HostProtection(Synchronization = true, ExternalThreading = true)]
  81.     internal sealed class TimerBase : CriticalFinalizerObject, IDisposable
  82.     {
  83.         #pragma warning disable 169
  84.         private IntPtr timerHandle;
  85.         private IntPtr delegateInfo;
  86.         #pragma warning restore 169
  87.         private int timerDeleted;
  88.         private int m_lock = 0;
  89.        
  90.         ~TimerBase()
  91.         {
  92.             // lock(this) cannot be used reliably in Cer since thin lock could be
  93.             // promoted to syncblock and that is not a guaranteed operation
  94.             bool bLockTaken = false;
  95.             do {
  96.                 if (Interlocked.CompareExchange(ref m_lock, 1, 0) == 0) {
  97.                     bLockTaken = true;
  98.                     try {
  99.                         DeleteTimerNative(null);
  100.                     }
  101.                     finally {
  102.                         m_lock = 0;
  103.                     }
  104.                 }
  105.                 Thread.SpinWait(1);
  106.                 // yield to processor
  107.             }
  108.             while (!bLockTaken);
  109.         }
  110.        
  111.         internal void AddTimer(TimerCallback callback, object state, UInt32 dueTime, UInt32 period, ref StackCrawlMark stackMark)
  112.         {
  113.             if (callback != null) {
  114.                 _TimerCallback callbackHelper = new _TimerCallback(callback, state, ref stackMark);
  115.                 state = (object)callbackHelper;
  116.                 AddTimerNative(state, dueTime, period, ref stackMark);
  117.                 timerDeleted = 0;
  118.             }
  119.             else {
  120.                 throw new ArgumentNullException("TimerCallback");
  121.             }
  122.         }
  123.        
  124.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  125.         internal bool ChangeTimer(UInt32 dueTime, UInt32 period)
  126.         {
  127.             bool status = false;
  128.             bool bLockTaken = false;
  129.            
  130.             // prepare here to prevent threadabort from occuring which could
  131.             // destroy m_lock state. lock(this) can't be used due to critical
  132.             // finalizer and thinlock/syncblock escalation.
  133.             RuntimeHelpers.PrepareConstrainedRegions();
  134.             try {
  135.             }
  136.             finally {
  137.                 do {
  138.                     if (Interlocked.CompareExchange(ref m_lock, 1, 0) == 0) {
  139.                         bLockTaken = true;
  140.                         try {
  141.                             if (timerDeleted != 0)
  142.                                 throw new ObjectDisposedException(null, Environment.GetResourceString("ObjectDisposed_Generic"));
  143.                             status = ChangeTimerNative(dueTime, period);
  144.                         }
  145.                         finally {
  146.                             m_lock = 0;
  147.                         }
  148.                     }
  149.                     Thread.SpinWait(1);
  150.                     // yield to processor
  151.                 }
  152.                 while (!bLockTaken);
  153.             }
  154.             return status;
  155.            
  156.         }
  157.        
  158.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  159.         internal bool Dispose(WaitHandle notifyObject)
  160.         {
  161.             bool status = false;
  162.             bool bLockTaken = false;
  163.             RuntimeHelpers.PrepareConstrainedRegions();
  164.             try {
  165.             }
  166.             finally {
  167.                 do {
  168.                     if (Interlocked.CompareExchange(ref m_lock, 1, 0) == 0) {
  169.                         bLockTaken = true;
  170.                         try {
  171.                             status = DeleteTimerNative(notifyObject.SafeWaitHandle);
  172.                         }
  173.                         finally {
  174.                             m_lock = 0;
  175.                         }
  176.                     }
  177.                     Thread.SpinWait(1);
  178.                     // yield to processor
  179.                 }
  180.                 while (!bLockTaken);
  181.                 GC.SuppressFinalize(this);
  182.             }
  183.            
  184.             return status;
  185.         }
  186.        
  187.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  188.         public void Dispose()
  189.         {
  190.             bool bLockTaken = false;
  191.             RuntimeHelpers.PrepareConstrainedRegions();
  192.             try {
  193.             }
  194.             finally {
  195.                 do {
  196.                     if (Interlocked.CompareExchange(ref m_lock, 1, 0) == 0) {
  197.                         bLockTaken = true;
  198.                         try {
  199.                             DeleteTimerNative(null);
  200.                         }
  201.                         finally {
  202.                             m_lock = 0;
  203.                         }
  204.                     }
  205.                     Thread.SpinWait(1);
  206.                     // yield to processor
  207.                 }
  208.                 while (!bLockTaken);
  209.                 GC.SuppressFinalize(this);
  210.             }
  211.         }
  212.        
  213.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  214.         private extern void AddTimerNative(object state, UInt32 dueTime, UInt32 period, ref StackCrawlMark stackMark);
  215.        
  216.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  217.         private extern bool ChangeTimerNative(UInt32 dueTime, UInt32 period);
  218.        
  219.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  220.         private extern bool DeleteTimerNative(SafeHandle notifyObject);
  221.        
  222.     }
  223.    
  224.     [HostProtection(Synchronization = true, ExternalThreading = true)]
  225.     [System.Runtime.InteropServices.ComVisible(true)]
  226.     public sealed class Timer : MarshalByRefObject, IDisposable
  227.     {
  228.         private const UInt32 MAX_SUPPORTED_TIMEOUT = (uint)4294967294u;
  229.         private TimerBase timerBase;
  230.        
  231.         public Timer(TimerCallback callback, object state, int dueTime, int period)
  232.         {
  233.             if (dueTime < -1)
  234.                 throw new ArgumentOutOfRangeException("dueTime", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
  235.             if (period < -1)
  236.                 throw new ArgumentOutOfRangeException("period", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
  237.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  238.            
  239.             TimerSetup(callback, state, (UInt32)dueTime, (UInt32)period, ref stackMark);
  240.         }
  241.        
  242.         public Timer(TimerCallback callback, object state, TimeSpan dueTime, TimeSpan period)
  243.         {
  244.             long dueTm = (long)dueTime.TotalMilliseconds;
  245.             if (dueTm < -1)
  246.                 throw new ArgumentOutOfRangeException("dueTm", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
  247.             if (dueTm > MAX_SUPPORTED_TIMEOUT)
  248.                 throw new ArgumentOutOfRangeException("dueTm", Environment.GetResourceString("ArgumentOutOfRange_TimeoutTooLarge"));
  249.            
  250.             long periodTm = (long)period.TotalMilliseconds;
  251.             if (periodTm < -1)
  252.                 throw new ArgumentOutOfRangeException("periodTm", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
  253.             if (periodTm > MAX_SUPPORTED_TIMEOUT)
  254.                 throw new ArgumentOutOfRangeException("periodTm", Environment.GetResourceString("ArgumentOutOfRange_PeriodTooLarge"));
  255.            
  256.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  257.             TimerSetup(callback, state, (UInt32)dueTm, (UInt32)periodTm, ref stackMark);
  258.         }
  259.        
  260.         [CLSCompliant(false)]
  261.         public Timer(TimerCallback callback, object state, UInt32 dueTime, UInt32 period)
  262.         {
  263.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  264.             TimerSetup(callback, state, dueTime, period, ref stackMark);
  265.         }
  266.        
  267.         public Timer(TimerCallback callback, object state, long dueTime, long period)
  268.         {
  269.             if (dueTime < -1)
  270.                 throw new ArgumentOutOfRangeException("dueTime", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
  271.             if (period < -1)
  272.                 throw new ArgumentOutOfRangeException("period", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
  273.             if (dueTime > MAX_SUPPORTED_TIMEOUT)
  274.                 throw new ArgumentOutOfRangeException("dueTime", Environment.GetResourceString("ArgumentOutOfRange_TimeoutTooLarge"));
  275.             if (period > MAX_SUPPORTED_TIMEOUT)
  276.                 throw new ArgumentOutOfRangeException("period", Environment.GetResourceString("ArgumentOutOfRange_PeriodTooLarge"));
  277.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  278.             TimerSetup(callback, state, (UInt32)dueTime, (UInt32)period, ref stackMark);
  279.         }
  280.        
  281.         public Timer(TimerCallback callback)
  282.         {
  283.             int dueTime = -1;
  284.             // we want timer to be registered, but not activated. Requires caller to call
  285.             int period = -1;
  286.             // Change after a timer instance is created. This is to avoid the potential
  287.             // for a timer to be fired before the returned value is assigned to the variable,
  288.             // potentially causing the callback to reference a bogus value (if passing the timer to the callback).
  289.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  290.             TimerSetup(callback, this, (UInt32)dueTime, (UInt32)period, ref stackMark);
  291.         }
  292.        
  293.         private void TimerSetup(TimerCallback callback, object state, UInt32 dueTime, UInt32 period, ref StackCrawlMark stackMark)
  294.         {
  295.             timerBase = new TimerBase();
  296.             timerBase.AddTimer(callback, state, (UInt32)dueTime, (UInt32)period, ref stackMark);
  297.         }
  298.        
  299.         public bool Change(int dueTime, int period)
  300.         {
  301.             if (dueTime < -1)
  302.                 throw new ArgumentOutOfRangeException("dueTime", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
  303.             if (period < -1)
  304.                 throw new ArgumentOutOfRangeException("period", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
  305.            
  306.             return timerBase.ChangeTimer((UInt32)dueTime, (UInt32)period);
  307.         }
  308.        
  309.         public bool Change(TimeSpan dueTime, TimeSpan period)
  310.         {
  311.             return Change((long)dueTime.TotalMilliseconds, (long)period.TotalMilliseconds);
  312.         }
  313.        
  314.         [CLSCompliant(false)]
  315.         public bool Change(UInt32 dueTime, UInt32 period)
  316.         {
  317.             return timerBase.ChangeTimer(dueTime, period);
  318.         }
  319.        
  320.         public bool Change(long dueTime, long period)
  321.         {
  322.             if (dueTime < -1)
  323.                 throw new ArgumentOutOfRangeException("dueTime", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
  324.             if (period < -1)
  325.                 throw new ArgumentOutOfRangeException("period", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
  326.             if (dueTime > MAX_SUPPORTED_TIMEOUT)
  327.                 throw new ArgumentOutOfRangeException("dueTime", Environment.GetResourceString("ArgumentOutOfRange_TimeoutTooLarge"));
  328.             if (period > MAX_SUPPORTED_TIMEOUT)
  329.                 throw new ArgumentOutOfRangeException("period", Environment.GetResourceString("ArgumentOutOfRange_PeriodTooLarge"));
  330.            
  331.             return timerBase.ChangeTimer((UInt32)dueTime, (UInt32)period);
  332.         }
  333.        
  334.         public bool Dispose(WaitHandle notifyObject)
  335.         {
  336.             if (notifyObject == null)
  337.                 throw new ArgumentNullException("notifyObject");
  338.             return timerBase.Dispose(notifyObject);
  339.         }
  340.        
  341.        
  342.         public void Dispose()
  343.         {
  344.             timerBase.Dispose();
  345.         }
  346.     }
  347. }

Developer Fusion