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 \ RegisteredWaitHandleSafe

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: ThreadPool
  18. **
  19. **
  20. ** Purpose: Class for creating and managing a threadpool
  21. **
  22. **
  23. =============================================================================*/
  25. /*
  26. * Below you'll notice two sets of APIs that are separated by the
  27. * use of 'Unsafe' in their names.  The unsafe versions are called
  28. * that because they do not propagate the calling stack onto the
  29. * worker thread.  This allows code to lose the calling stack and
  30. * thereby elevate its security privileges.  Note that this operation
  31. * is much akin to the combined ability to control security policy
  32. * and control security evidence.  With these privileges, a person
  33. * can gain the right to load assemblies that are fully trusted which
  34. * then assert full trust and can call any code they want regardless
  35. * of the previous stack information.
  36. */
  38. namespace System.Threading
  39. {
  40.     using System.Security;
  41.     using System.Threading;
  42.     using System.Runtime.Remoting;
  43.     using System.Security.Permissions;
  44.     using System;
  45.     using Microsoft.Win32;
  46.     using System.Runtime.CompilerServices;
  47.     using System.Runtime.ConstrainedExecution;
  48.     using System.Runtime.InteropServices;
  49.    
  50.     internal sealed class RegisteredWaitHandleSafe : CriticalFinalizerObject
  51.     {
  52.         private static readonly IntPtr InvalidHandle = Win32Native.INVALID_HANDLE_VALUE;
  53.         private IntPtr registeredWaitHandle;
  54.         private WaitHandle m_internalWaitObject;
  55.         private bool bReleaseNeeded = false;
  56.         private int m_lock = 0;
  57.        
  58.         internal RegisteredWaitHandleSafe()
  59.         {
  60.             registeredWaitHandle = InvalidHandle;
  61.         }
  62.        
  63.         internal IntPtr GetHandle()
  64.         {
  65.             return registeredWaitHandle;
  66.         }
  67.        
  68.         internal void SetHandle(IntPtr handle)
  69.         {
  70.             registeredWaitHandle = handle;
  71.         }
  72.        
  73.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  74.         internal void SetWaitObject(WaitHandle waitObject)
  75.         {
  76.             // needed for DangerousAddRef
  77.             RuntimeHelpers.PrepareConstrainedRegions();
  78.             try {
  79.             }
  80.             finally {
  81.                 m_internalWaitObject = waitObject;
  82.                 if (waitObject != null) {
  83.                     m_internalWaitObject.SafeWaitHandle.DangerousAddRef(ref bReleaseNeeded);
  84.                 }
  85.             }
  86.         }
  87.        
  88.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  89.         // object to be notified when all callbacks to delegates have completed
  90.         internal bool Unregister(WaitHandle waitObject)
  91.         {
  92.             bool result = false;
  93.             // needed for DangerousRelease
  94.             RuntimeHelpers.PrepareConstrainedRegions();
  95.             try {
  96.             }
  97.             finally {
  98.                 // lock(this) cannot be used reliably in Cer since thin lock could be
  99.                 // promoted to syncblock and that is not a guaranteed operation
  100.                 bool bLockTaken = false;
  101.                 do {
  102.                     if (Interlocked.CompareExchange(ref m_lock, 1, 0) == 0) {
  103.                         bLockTaken = true;
  104.                         try {
  105.                             if (ValidHandle()) {
  106.                                 result = UnregisterWaitNative(GetHandle(), waitObject == null ? null : waitObject.SafeWaitHandle);
  107.                                 if (result == true) {
  108.                                     if (bReleaseNeeded) {
  109.                                         m_internalWaitObject.SafeWaitHandle.DangerousRelease();
  110.                                         bReleaseNeeded = false;
  111.                                     }
  112.                                     // if result not true don't release/suppress here so finalizer can make another attempt
  113.                                     SetHandle(InvalidHandle);
  114.                                     m_internalWaitObject = null;
  115.                                     GC.SuppressFinalize(this);
  116.                                 }
  117.                             }
  118.                         }
  119.                         finally {
  120.                             m_lock = 0;
  121.                         }
  122.                     }
  123.                     Thread.SpinWait(1);
  124.                     // yield to processor
  125.                 }
  126.                 while (!bLockTaken);
  127.             }
  128.             return result;
  129.         }
  130.        
  131.         private bool ValidHandle()
  132.         {
  133.             return (registeredWaitHandle != InvalidHandle && registeredWaitHandle != IntPtr.Zero);
  134.         }
  135.        
  136.         ~RegisteredWaitHandleSafe()
  137.         {
  138.             // if the app has already unregistered the wait, there is nothing to cleanup
  139.             // we can detect this by checking the handle. Normally, there is no race here
  140.             // so no need to protect reading of handle. However, if this object gets
  141.             // resurrected and then someone does an unregister, it would introduce a race
  142.            
  143.             // PrepareConstrainedRegions call not needed since finalizer already in Cer
  144.            
  145.             // lock(this) cannot be used reliably even in Cer since thin lock could be
  146.             // promoted to syncblock and that is not a guaranteed operation
  147.            
  148.             bool bLockTaken = false;
  149.             do {
  150.                 if (Interlocked.CompareExchange(ref m_lock, 1, 0) == 0) {
  151.                     bLockTaken = true;
  152.                     try {
  153.                         if (ValidHandle()) {
  154.                             WaitHandleCleanupNative(registeredWaitHandle);
  155.                             if (bReleaseNeeded) {
  156.                                 m_internalWaitObject.SafeWaitHandle.DangerousRelease();
  157.                                 bReleaseNeeded = false;
  158.                             }
  159.                             SetHandle(InvalidHandle);
  160.                             m_internalWaitObject = null;
  161.                         }
  162.                     }
  163.                     finally {
  164.                         m_lock = 0;
  165.                     }
  166.                 }
  167.                 Thread.SpinWait(1);
  168.                 // yield to processor
  169.             }
  170.             while (!bLockTaken);
  171.         }
  172.        
  173.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  174.         private static extern void WaitHandleCleanupNative(IntPtr handle);
  175.        
  176.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  177.         private static extern bool UnregisterWaitNative(IntPtr handle, SafeHandle waitObject);
  178.     }
  179.    
  180.     [System.Runtime.InteropServices.ComVisible(true)]
  181.     public sealed class RegisteredWaitHandle : MarshalByRefObject
  182.     {
  183.         private RegisteredWaitHandleSafe internalRegisteredWait;
  184.        
  185.         internal RegisteredWaitHandle()
  186.         {
  187.             internalRegisteredWait = new RegisteredWaitHandleSafe();
  188.         }
  189.        
  190.         internal void SetHandle(IntPtr handle)
  191.         {
  192.             internalRegisteredWait.SetHandle(handle);
  193.         }
  194.        
  195.         internal void SetWaitObject(WaitHandle waitObject)
  196.         {
  197.             internalRegisteredWait.SetWaitObject(waitObject);
  198.         }
  199.        
  200.        
  201.         [System.Runtime.InteropServices.ComVisible(true)]
  202.         // This is the only public method on this class
  203.         // object to be notified when all callbacks to delegates have completed
  204.         public bool Unregister(WaitHandle waitObject)
  205.         {
  206.             return internalRegisteredWait.Unregister(waitObject);
  207.         }
  208.     }
  209.    
  210.     [System.Runtime.InteropServices.ComVisible(true)]
  211.     public delegate void WaitCallback(object state);
  212.    
  213.     [System.Runtime.InteropServices.ComVisible(true)]
  214.     public delegate void WaitOrTimerCallback(object state, bool timedOut);
  215.     // signalled or timed out
  216.     internal class _ThreadPoolWaitCallback
  217.     {
  218.         WaitCallback _waitCallback;
  219.         ExecutionContext _executionContext;
  220.         object _state;
  221.        
  222.         static internal ContextCallback _ccb = new ContextCallback(WaitCallback_Context);
  223.         static internal void WaitCallback_Context(object state)
  224.         {
  225.             _ThreadPoolWaitCallback obj = (_ThreadPoolWaitCallback)state;
  226.             obj._waitCallback(obj._state);
  227.         }
  228.        
  229.        
  230.         internal _ThreadPoolWaitCallback(WaitCallback waitCallback, object state, bool compressStack, ref StackCrawlMark stackMark)
  231.         {
  232.             _waitCallback = waitCallback;
  233.             _state = state;
  234.             if (compressStack && !ExecutionContext.IsFlowSuppressed()) {
  235.                 // clone the exection context
  236.                 _executionContext = ExecutionContext.Capture(ref stackMark);
  237.                 ExecutionContext.ClearSyncContext(_executionContext);
  238.             }
  239.         }
  240.        
  241.         // call back helper
  242.         static internal void PerformWaitCallback(object state)
  243.         {
  244.             _ThreadPoolWaitCallback helper = (_ThreadPoolWaitCallback)state;
  245.            
  246.             BCLDebug.Assert(helper != null, "Null state passed to PerformWaitCallback!");
  247.             // call directly if it is an unsafe call OR EC flow is suppressed
  248.             if (helper._executionContext == null) {
  249.                 WaitCallback callback = helper._waitCallback;
  250.                 callback(helper._state);
  251.             }
  252.             else {
  253.                 ExecutionContext.Run(helper._executionContext, _ccb, helper);
  254.             }
  255.         }
  256.     }
  257.    
  258.     internal class _ThreadPoolWaitOrTimerCallback
  259.     {
  260.         WaitOrTimerCallback _waitOrTimerCallback;
  261.         ExecutionContext _executionContext;
  262.         object _state;
  263.         private static ContextCallback _ccbt = new ContextCallback(WaitOrTimerCallback_Context_t);
  264.         private static ContextCallback _ccbf = new ContextCallback(WaitOrTimerCallback_Context_f);
  265.        
  266.         internal _ThreadPoolWaitOrTimerCallback(WaitOrTimerCallback waitOrTimerCallback, object state, bool compressStack, ref StackCrawlMark stackMark)
  267.         {
  268.             _waitOrTimerCallback = waitOrTimerCallback;
  269.             _state = state;
  270.             if (compressStack && !ExecutionContext.IsFlowSuppressed()) {
  271.                 // capture the exection context
  272.                 _executionContext = ExecutionContext.Capture(ref stackMark);
  273.                 ExecutionContext.ClearSyncContext(_executionContext);
  274.             }
  275.         }
  276.         private static void WaitOrTimerCallback_Context_t(object state)
  277.         {
  278.             WaitOrTimerCallback_Context(state, true);
  279.         }
  280.         private static void WaitOrTimerCallback_Context_f(object state)
  281.         {
  282.             WaitOrTimerCallback_Context(state, false);
  283.         }
  284.        
  285.         private static void WaitOrTimerCallback_Context(object state, bool timedOut)
  286.         {
  287.             _ThreadPoolWaitOrTimerCallback helper = (_ThreadPoolWaitOrTimerCallback)state;
  288.             helper._waitOrTimerCallback(helper._state, timedOut);
  289.         }
  290.        
  291.        
  292.         // call back helper
  293.         static internal void PerformWaitOrTimerCallback(object state, bool timedOut)
  294.         {
  295.             _ThreadPoolWaitOrTimerCallback helper = (_ThreadPoolWaitOrTimerCallback)state;
  296.             BCLDebug.Assert(helper != null, "Null state passed to PerformWaitOrTimerCallback!");
  297.             // call directly if it is an unsafe call OR EC flow is suppressed
  298.             if (helper._executionContext == null) {
  299.                 WaitOrTimerCallback callback = helper._waitOrTimerCallback;
  300.                 callback(helper._state, timedOut);
  301.             }
  302.             else {
  303.                 if (timedOut)
  304.                     ExecutionContext.Run(helper._executionContext.CreateCopy(), _ccbt, helper);
  305.                 else
  306.                     ExecutionContext.Run(helper._executionContext.CreateCopy(), _ccbf, helper);
  307.             }
  308.         }
  309.     }
  310.    
  311.     [CLSCompliant(false)]
  312.     [System.Runtime.InteropServices.ComVisible(true)]
  313.         // Error code
  314.         // No. of bytes transferred
  315.         // ptr to OVERLAP structure
  316.     unsafe public delegate void IOCompletionCallback(uint errorCode, uint numBytes, NativeOverlapped* pOVERLAP);
  317.    
  318.     [HostProtection(Synchronization = true, ExternalThreading = true)]
  319.     public static class ThreadPool
  320.     {
  321.        
  322.         [SecurityPermissionAttribute(SecurityAction.Demand, ControlThread = true)]
  323.         public static bool SetMaxThreads(int workerThreads, int completionPortThreads)
  324.         {
  325.             return SetMaxThreadsNative(workerThreads, completionPortThreads);
  326.         }
  327.        
  328.         public static void GetMaxThreads(out int workerThreads, out int completionPortThreads)
  329.         {
  330.             GetMaxThreadsNative(out workerThreads, out completionPortThreads);
  331.         }
  332.        
  333.         [SecurityPermissionAttribute(SecurityAction.Demand, ControlThread = true)]
  334.         public static bool SetMinThreads(int workerThreads, int completionPortThreads)
  335.         {
  336.             return SetMinThreadsNative(workerThreads, completionPortThreads);
  337.         }
  338.        
  339.         public static void GetMinThreads(out int workerThreads, out int completionPortThreads)
  340.         {
  341.             GetMinThreadsNative(out workerThreads, out completionPortThreads);
  342.         }
  343.        
  344.         public static void GetAvailableThreads(out int workerThreads, out int completionPortThreads)
  345.         {
  346.             GetAvailableThreadsNative(out workerThreads, out completionPortThreads);
  347.         }
  348.        
  349.         [CLSCompliant(false)]
  350.             // throws RegisterWaitException
  351.         // NOTE: we do not allow other options that allow the callback to be queued as an APC
  352.         public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object state, uint millisecondsTimeOutInterval, bool executeOnlyOnce)
  353.         {
  354.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  355.             return RegisterWaitForSingleObject(waitObject, callBack, state, millisecondsTimeOutInterval, executeOnlyOnce, ref stackMark, true);
  356.         }
  357.        
  358.         [CLSCompliant(false), SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.ControlEvidence | SecurityPermissionFlag.ControlPolicy)]
  359.             // throws RegisterWaitException
  360.         // NOTE: we do not allow other options that allow the callback to be queued as an APC
  361.         public static RegisteredWaitHandle UnsafeRegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object state, uint millisecondsTimeOutInterval, bool executeOnlyOnce)
  362.         {
  363.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  364.             return RegisterWaitForSingleObject(waitObject, callBack, state, millisecondsTimeOutInterval, executeOnlyOnce, ref stackMark, false);
  365.         }
  366.        
  367.        
  368.             // throws RegisterWaitException
  369.             // NOTE: we do not allow other options that allow the callback to be queued as an APC
  370.         private static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object state, uint millisecondsTimeOutInterval, bool executeOnlyOnce, ref StackCrawlMark stackMark, bool compressStack)
  371.         {
  372.             if (RemotingServices.IsTransparentProxy(waitObject))
  373.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_WaitOnTransparentProxy"));
  374.             RegisteredWaitHandle registeredWaitHandle = new RegisteredWaitHandle();
  375.            
  376.             if (callBack != null) {
  377.                 _ThreadPoolWaitOrTimerCallback callBackHelper = new _ThreadPoolWaitOrTimerCallback(callBack, state, compressStack, ref stackMark);
  378.                 state = (object)callBackHelper;
  379.                 // call SetWaitObject before native call so that waitObject won't be closed before threadpoolmgr registration
  380.                 // this could occur if callback were to fire before SetWaitObject does its addref
  381.                 registeredWaitHandle.SetWaitObject(waitObject);
  382.                 IntPtr nativeRegisteredWaitHandle = RegisterWaitForSingleObjectNative(waitObject, state, millisecondsTimeOutInterval, executeOnlyOnce, registeredWaitHandle, ref stackMark, compressStack);
  383.                 registeredWaitHandle.SetHandle(nativeRegisteredWaitHandle);
  384.             }
  385.             else {
  386.                 throw new ArgumentNullException("WaitOrTimerCallback");
  387.             }
  388.             return registeredWaitHandle;
  389.         }
  390.        
  391.        
  392.        
  393.             // throws RegisterWaitException
  394.         // NOTE: we do not allow other options that allow the callback to be queued as an APC
  395.         public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object state, int millisecondsTimeOutInterval, bool executeOnlyOnce)
  396.         {
  397.             if (millisecondsTimeOutInterval < -1)
  398.                 throw new ArgumentOutOfRangeException("millisecondsTimeOutInterval", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
  399.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  400.             return RegisterWaitForSingleObject(waitObject, callBack, state, (UInt32)millisecondsTimeOutInterval, executeOnlyOnce, ref stackMark, true);
  401.         }
  402.        
  403.         [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.ControlEvidence | SecurityPermissionFlag.ControlPolicy)]
  404.             // throws RegisterWaitException
  405.         // NOTE: we do not allow other options that allow the callback to be queued as an APC
  406.         public static RegisteredWaitHandle UnsafeRegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object state, int millisecondsTimeOutInterval, bool executeOnlyOnce)
  407.         {
  408.             if (millisecondsTimeOutInterval < -1)
  409.                 throw new ArgumentOutOfRangeException("millisecondsTimeOutInterval", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
  410.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  411.             return RegisterWaitForSingleObject(waitObject, callBack, state, (UInt32)millisecondsTimeOutInterval, executeOnlyOnce, ref stackMark, false);
  412.         }
  413.        
  414.             // throws RegisterWaitException
  415.         // NOTE: we do not allow other options that allow the callback to be queued as an APC
  416.         public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object state, long millisecondsTimeOutInterval, bool executeOnlyOnce)
  417.         {
  418.             if (millisecondsTimeOutInterval < -1)
  419.                 throw new ArgumentOutOfRangeException("millisecondsTimeOutInterval", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
  420.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  421.             return RegisterWaitForSingleObject(waitObject, callBack, state, (UInt32)millisecondsTimeOutInterval, executeOnlyOnce, ref stackMark, true);
  422.         }
  423.        
  424.         [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.ControlEvidence | SecurityPermissionFlag.ControlPolicy)]
  425.             // throws RegisterWaitException
  426.         // NOTE: we do not allow other options that allow the callback to be queued as an APC
  427.         public static RegisteredWaitHandle UnsafeRegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object state, long millisecondsTimeOutInterval, bool executeOnlyOnce)
  428.         {
  429.             if (millisecondsTimeOutInterval < -1)
  430.                 throw new ArgumentOutOfRangeException("millisecondsTimeOutInterval", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
  431.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  432.             return RegisterWaitForSingleObject(waitObject, callBack, state, (UInt32)millisecondsTimeOutInterval, executeOnlyOnce, ref stackMark, false);
  433.         }
  434.        
  435.        
  436.         public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object state, TimeSpan timeout, bool executeOnlyOnce)
  437.         {
  438.             long tm = (long)timeout.TotalMilliseconds;
  439.             if (tm < -1)
  440.                 throw new ArgumentOutOfRangeException("timeout", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
  441.             if (tm > (long)Int32.MaxValue)
  442.                 throw new ArgumentOutOfRangeException("timeout", Environment.GetResourceString("ArgumentOutOfRange_LessEqualToIntegerMaxVal"));
  443.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  444.             return RegisterWaitForSingleObject(waitObject, callBack, state, (UInt32)tm, executeOnlyOnce, ref stackMark, true);
  445.         }
  446.        
  447.         [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.ControlEvidence | SecurityPermissionFlag.ControlPolicy)]
  448.         public static RegisteredWaitHandle UnsafeRegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object state, TimeSpan timeout, bool executeOnlyOnce)
  449.         {
  450.             long tm = (long)timeout.TotalMilliseconds;
  451.             if (tm < -1)
  452.                 throw new ArgumentOutOfRangeException("timeout", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
  453.             if (tm > (long)Int32.MaxValue)
  454.                 throw new ArgumentOutOfRangeException("timeout", Environment.GetResourceString("ArgumentOutOfRange_LessEqualToIntegerMaxVal"));
  455.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  456.             return RegisterWaitForSingleObject(waitObject, callBack, state, (UInt32)tm, executeOnlyOnce, ref stackMark, false);
  457.         }
  458.        
  459.             // NOTE: we do not expose options that allow the callback to be queued as an APC
  460.         public static bool QueueUserWorkItem(WaitCallback callBack, object state)
  461.         {
  462.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  463.             return QueueUserWorkItemHelper(callBack, state, ref stackMark, true);
  464.         }
  465.        
  466.         // NOTE: we do not expose options that allow the callback to be queued as an APC
  467.         public static bool QueueUserWorkItem(WaitCallback callBack)
  468.         {
  469.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  470.             return QueueUserWorkItemHelper(callBack, null, ref stackMark, true);
  471.         }
  472.        
  473.         [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.ControlEvidence | SecurityPermissionFlag.ControlPolicy)]
  474.             // NOTE: we do not expose options that allow the callback to be queued as an APC
  475.         public static bool UnsafeQueueUserWorkItem(WaitCallback callBack, object state)
  476.         {
  477.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  478.             return QueueUserWorkItemHelper(callBack, state, ref stackMark, false);
  479.         }
  480.        
  481.         private static bool QueueUserWorkItemHelper(WaitCallback callBack, object state, ref StackCrawlMark stackMark, bool compressStack)
  482.         {
  483.             if (callBack != null) {
  484.                 _ThreadPoolWaitCallback callBackHelper = new _ThreadPoolWaitCallback(callBack, state, compressStack, ref stackMark);
  485.                 state = (object)callBackHelper;
  486.                 return QueueUserWorkItem(state, ref stackMark, compressStack);
  487.             }
  488.             else {
  489.                 throw new ArgumentNullException("WaitCallback");
  490.             }
  491.            
  492.         }
  493.        
  494.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  495.         private static extern bool QueueUserWorkItem(object state, ref StackCrawlMark stackMark, bool compressStack);
  496.        
  497.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  498.         unsafe private static extern bool PostQueuedCompletionStatus(NativeOverlapped* overlapped);
  499.        
  500.         [CLSCompliant(false)]
  501.         [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.ControlEvidence | SecurityPermissionFlag.ControlPolicy)]
  502.         unsafe public static bool UnsafeQueueNativeOverlapped(NativeOverlapped* overlapped)
  503.         {
  504.             return PostQueuedCompletionStatus(overlapped);
  505.         }
  506.        
  507.         // Native methods:
  508.        
  509.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  510.         private static extern bool SetMinThreadsNative(int workerThreads, int completionPortThreads);
  511.        
  512.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  513.         private static extern bool SetMaxThreadsNative(int workerThreads, int completionPortThreads);
  514.        
  515.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  516.         private static extern void GetMinThreadsNative(out int workerThreads, out int completionPortThreads);
  517.        
  518.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  519.         private static extern void GetMaxThreadsNative(out int workerThreads, out int completionPortThreads);
  520.        
  521.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  522.         private static extern void GetAvailableThreadsNative(out int workerThreads, out int completionPortThreads);
  523.        
  524.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  525.         private static extern IntPtr RegisterWaitForSingleObjectNative(WaitHandle waitHandle, object state, uint timeOutInterval, bool executeOnlyOnce, RegisteredWaitHandle registeredWaitHandle, ref StackCrawlMark stackMark, bool compressStack);
  526.        
  527.         [Obsolete("ThreadPool.BindHandle(IntPtr) has been deprecated. Please use ThreadPool.BindHandle(SafeHandle) instead.", false)]
  528.         [SecurityPermissionAttribute(SecurityAction.Demand, Flags = SecurityPermissionFlag.UnmanagedCode)]
  529.         public static bool BindHandle(IntPtr osHandle)
  530.         {
  531.             return BindIOCompletionCallbackNative(osHandle);
  532.         }
  533.        
  534.         [SecurityPermissionAttribute(SecurityAction.Demand, Flags = SecurityPermissionFlag.UnmanagedCode)]
  535.         public static bool BindHandle(SafeHandle osHandle)
  536.         {
  537.             if (osHandle == null)
  538.                 throw new ArgumentNullException("osHandle");
  539.            
  540.             bool ret = false;
  541.             bool mustReleaseSafeHandle = false;
  542.             RuntimeHelpers.PrepareConstrainedRegions();
  543.             try {
  544.                 osHandle.DangerousAddRef(ref mustReleaseSafeHandle);
  545.                 ret = BindIOCompletionCallbackNative(osHandle.DangerousGetHandle());
  546.             }
  547.             finally {
  548.                 if (mustReleaseSafeHandle)
  549.                     osHandle.DangerousRelease();
  550.             }
  551.             return ret;
  552.         }
  553.        
  554.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  555.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  556.         private static extern bool BindIOCompletionCallbackNative(IntPtr fileHandle);
  557.     }
  558. }

Developer Fusion