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

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: EventWaitHandle
  18. **
  19. **
  20. ** Purpose: Base class for representing Events
  21. **
  22. **
  23. =============================================================================*/
  25. namespace System.Threading
  26. {
  27.     using System;
  28.     using System.Threading;
  29.     using System.Runtime.CompilerServices;
  30.     using System.Security.Permissions;
  31.     using System.IO;
  32.     using Microsoft.Win32;
  33.     using Microsoft.Win32.SafeHandles;
  34.     using System.Runtime.InteropServices;
  35.     using System.Runtime.Versioning;
  36.    
  37.     [HostProtection(Synchronization = true, ExternalThreading = true)]
  38.     [ComVisibleAttribute(true)]
  39.     public class EventWaitHandle : WaitHandle
  40.     {
  41.         [ResourceExposure(ResourceScope.None)]
  42.         [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
  43.         public EventWaitHandle(bool initialState, EventResetMode mode) : this(initialState, mode, null)
  44.         {
  45.         }
  46.        
  47.         [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
  48.         [ResourceExposure(ResourceScope.Machine)]
  49.         [ResourceConsumption(ResourceScope.Machine)]
  50.         public EventWaitHandle(bool initialState, EventResetMode mode, string name)
  51.         {
  52.             if (null != name && System.IO.Path.MAX_PATH < name.Length) {
  53.                 throw new ArgumentException(Environment.GetResourceString("Argument_WaitHandleNameTooLong", name));
  54.             }
  55.            
  56.             SafeWaitHandle _handle = null;
  57.             switch (mode) {
  58.                 case EventResetMode.ManualReset:
  59.                     _handle = Win32Native.CreateEvent(null, true, initialState, name);
  60.                     break;
  61.                 case EventResetMode.AutoReset:
  62.                     _handle = Win32Native.CreateEvent(null, false, initialState, name);
  63.                     break;
  64.                 default:
  65.                    
  66.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidFlag", name));
  67.                     break;
  68.             }
  69.             ;
  70.            
  71.             if (_handle.IsInvalid) {
  72.                 int errorCode = Marshal.GetLastWin32Error();
  73.                
  74.                 _handle.SetHandleAsInvalid();
  75.                 if (null != name && 0 != name.Length && Win32Native.ERROR_INVALID_HANDLE == errorCode)
  76.                     throw new WaitHandleCannotBeOpenedException(Environment.GetResourceString("Threading.WaitHandleCannotBeOpenedException_InvalidHandle", name));
  77.                
  78.                 __Error.WinIOError(errorCode, "");
  79.             }
  80.             SetHandleInternal(_handle);
  81.         }
  82.        
  83.         [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
  84.         [ResourceExposure(ResourceScope.Machine)]
  85.         [ResourceConsumption(ResourceScope.Machine)]
  86.         public EventWaitHandle(bool initialState, EventResetMode mode, string name, out bool createdNew)
  87.         {
  88.             if (null != name && System.IO.Path.MAX_PATH < name.Length) {
  89.                 throw new ArgumentException(Environment.GetResourceString("Argument_WaitHandleNameTooLong", name));
  90.             }
  91.             Win32Native.SECURITY_ATTRIBUTES secAttrs = null;
  92.            
  93.             SafeWaitHandle _handle = null;
  94.             bool isManualReset;
  95.             switch (mode) {
  96.                 case EventResetMode.ManualReset:
  97.                     isManualReset = true;
  98.                     break;
  99.                 case EventResetMode.AutoReset:
  100.                     isManualReset = false;
  101.                     break;
  102.                 default:
  103.                    
  104.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidFlag", name));
  105.                     break;
  106.             }
  107.             ;
  108.            
  109.             _handle = Win32Native.CreateEvent(secAttrs, isManualReset, initialState, name);
  110.             int errorCode = Marshal.GetLastWin32Error();
  111.            
  112.             if (_handle.IsInvalid) {
  113.                
  114.                 _handle.SetHandleAsInvalid();
  115.                 if (null != name && 0 != name.Length && Win32Native.ERROR_INVALID_HANDLE == errorCode)
  116.                     throw new WaitHandleCannotBeOpenedException(Environment.GetResourceString("Threading.WaitHandleCannotBeOpenedException_InvalidHandle", name));
  117.                
  118.                 __Error.WinIOError(errorCode, name);
  119.             }
  120.             createdNew = errorCode != Win32Native.ERROR_ALREADY_EXISTS;
  121.             SetHandleInternal(_handle);
  122.         }
  123.        
  124.         private EventWaitHandle(SafeWaitHandle handle)
  125.         {
  126.             SetHandleInternal(handle);
  127.         }
  128.        
  129.         [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
  130.         [ResourceExposure(ResourceScope.Machine)]
  131.         [ResourceConsumption(ResourceScope.Machine)]
  132.         public static EventWaitHandle OpenExisting(string name)
  133.         {
  134.             if (name == null) {
  135.                 throw new ArgumentNullException("name", Environment.GetResourceString("ArgumentNull_WithParamName"));
  136.             }
  137.            
  138.             if (name.Length == 0) {
  139.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "name");
  140.             }
  141.            
  142.             if (null != name && System.IO.Path.MAX_PATH < name.Length) {
  143.                 throw new ArgumentException(Environment.GetResourceString("Argument_WaitHandleNameTooLong", name));
  144.             }
  145.            
  146.            
  147.             SafeWaitHandle myHandle = Win32Native.OpenEvent(Win32Native.EVENT_MODIFY_STATE | Win32Native.SYNCHRONIZE, false, name);
  148.            
  149.             if (myHandle.IsInvalid) {
  150.                 int errorCode = Marshal.GetLastWin32Error();
  151.                
  152.                 if (Win32Native.ERROR_FILE_NOT_FOUND == errorCode || Win32Native.ERROR_INVALID_NAME == errorCode)
  153.                     throw new WaitHandleCannotBeOpenedException();
  154.                 if (null != name && 0 != name.Length && Win32Native.ERROR_INVALID_HANDLE == errorCode)
  155.                     throw new WaitHandleCannotBeOpenedException(Environment.GetResourceString("Threading.WaitHandleCannotBeOpenedException_InvalidHandle", name));
  156.                 //this is for passed through Win32Native Errors
  157.                 __Error.WinIOError(errorCode, "");
  158.             }
  159.             return new EventWaitHandle(myHandle);
  160.         }
  161.         public bool Reset()
  162.         {
  163.             bool res = Win32Native.ResetEvent(safeWaitHandle);
  164.             if (!res)
  165.                 __Error.WinIOError();
  166.             return res;
  167.         }
  168.         public bool Set()
  169.         {
  170.             bool res = Win32Native.SetEvent(safeWaitHandle);
  171.            
  172.             if (!res)
  173.                 __Error.WinIOError();
  174.            
  175.             return res;
  176.         }
  177.        
  178.     }
  179. }

Developer Fusion