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 \ Microsoft.Win32.SafeHandles \ SafeWaitHandle

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:  SafeWaitHandle
  18. **
  19. **
  20. ** A wrapper for Win32 events (mutexes, auto reset events, and
  21. ** manual reset events).  Used by WaitHandle.
  22. **
  23. **
  24. ===========================================================*/
  26. using System;
  27. using System.Security;
  28. using System.Security.Permissions;
  29. using System.Runtime.InteropServices;
  30. using System.Runtime.CompilerServices;
  31. using System.Runtime.ConstrainedExecution;
  32. using System.Runtime.Versioning;
  33. using Microsoft.Win32;
  34. using System.Threading;
  36. namespace Microsoft.Win32.SafeHandles
  37. {
  38.    
  39.     [SecurityPermission(SecurityAction.LinkDemand, UnmanagedCode = true)]
  40.     public sealed class SafeWaitHandle : SafeHandleZeroOrMinusOneIsInvalid
  41.     {
  42.        
  43.         // Special case flags for Mutexes enables workaround for known OS bug at
  44.         // http://support.microsoft.com/default.aspx?scid=kb;en-us;889318
  45.         // One machine-wide mutex serializes all OpenMutex and CloseHandle operations.
  46.        
  47.        
  48.         // bIsMutex: if true, we need to grab machine-wide mutex before doing any Close ops.
  49.         private bool bIsMutex = false;
  50.        
  51.         // bIsMutex: if true, we need to avoid grabbing the machine-wide mutex before Close ops,
  52.         // since that mutex is, of course, this very handle.
  53.         private bool bIsReservedMutex = false;
  54.         // Called by P/Invoke marshaler
  55.         private SafeWaitHandle() : base(true)
  56.         {
  57.         }
  58.        
  59.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  60.         public SafeWaitHandle(IntPtr existingHandle, bool ownsHandle) : base(ownsHandle)
  61.         {
  62.             SetHandle(existingHandle);
  63.         }
  64.        
  65.         [ResourceExposure(ResourceScope.Machine)]
  66.         [ResourceConsumption(ResourceScope.Machine)]
  67.         protected override bool ReleaseHandle()
  68.         {
  69.             if (!bIsMutex || Environment.HasShutdownStarted)
  70.                 return Win32Native.CloseHandle(handle);
  71.            
  72.             bool bReturn = false;
  73.             bool bMutexObtained = false;
  74.             try {
  75.                 if (!bIsReservedMutex) {
  76.                     Mutex.AcquireReservedMutex(ref bMutexObtained);
  77.                 }
  78.                 bReturn = Win32Native.CloseHandle(handle);
  79.             }
  80.             finally {
  81.                 if (bMutexObtained)
  82.                     Mutex.ReleaseReservedMutex();
  83.             }
  84.             return bReturn;
  85.         }
  86.        
  87.         internal void SetAsMutex()
  88.         {
  89.             bIsMutex = true;
  90.         }
  91.        
  92.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  93.         internal void SetAsReservedMutex()
  94.         {
  95.             bIsReservedMutex = true;
  96.         }
  97.     }
  98. }

Developer Fusion