public EventWaitHandle(bool initialState, EventResetMode mode, string name) { if (name != null && 260 < name.Length) { throw new ArgumentException(Environment.GetResourceString("Argument_WaitHandleNameTooLong", (object)name)); } SafeWaitHandle @event; if (mode != EventResetMode.AutoReset) { if (mode == EventResetMode.ManualReset) { @event = Win32Native.CreateEvent((Win32Native.SECURITY_ATTRIBUTES)null, true, initialState, name); } else { throw new ArgumentException(Environment.GetResourceString("Argument_InvalidFlag", (object)name)); } } else { @event = Win32Native.CreateEvent((Win32Native.SECURITY_ATTRIBUTES)null, false, initialState, name); } if (@event.IsInvalid) { int lastWin32Error = Marshal.GetLastWin32Error(); @event.SetHandleAsInvalid(); if (name != null && name.Length != 0 && 6 == lastWin32Error) { throw new WaitHandleCannotBeOpenedException(Environment.GetResourceString("Threading.WaitHandleCannotBeOpenedException_InvalidHandle", (object)name)); } __Error.WinIOError(lastWin32Error, name); } this.SetHandleInternal(@event); }
public EventWaitHandle(bool initialState, EventResetMode mode, string name, out bool createdNew) { bool manual = IsManualReset(mode); Handle = NativeEventCalls.CreateEvent_internal(manual, initialState, name, out createdNew); }
/// <summary>Initializes a new instance of the <see cref="T:System.Threading.EventWaitHandle" /> class, specifying whether the wait handle is initially signaled if created as a result of this call, whether it resets automatically or manually, and the name of a system synchronization event.</summary> /// <param name="initialState">true to set the initial state to signaled if the named event is created as a result of this call; false to set it to nonsignaled.</param> /// <param name="mode">One of the <see cref="T:System.Threading.EventResetMode" /> values that determines whether the event resets automatically or manually.</param> /// <param name="name">The name of a system-wide synchronization event.</param> /// <exception cref="T:System.IO.IOException">A Win32 error occurred.</exception> /// <exception cref="T:System.UnauthorizedAccessException">The named event exists and has access control security, but the user does not have <see cref="F:System.Security.AccessControl.EventWaitHandleRights.FullControl" />.</exception> /// <exception cref="T:System.Threading.WaitHandleCannotBeOpenedException">The named event cannot be created, perhaps because a wait handle of a different type has the same name.</exception> /// <exception cref="T:System.ArgumentException"> /// <paramref name="name" /> is longer than 260 characters.</exception> public EventWaitHandle(bool initialState, EventResetMode mode, string name) { bool manual = this.IsManualReset(mode); bool flag; this.Handle = NativeEventCalls.CreateEvent_internal(manual, initialState, name, out flag); }
private static bool IsManualReset (EventResetMode mode) { if ((mode < EventResetMode.AutoReset) || (mode > EventResetMode.ManualReset)) { throw new ArgumentException ("mode"); } return mode == EventResetMode.ManualReset; }
public EventWaitHandle(bool initialState, EventResetMode mode, string name, out bool createdNew) { VerifyNameForCreate(name); VerifyMode(mode); CreateEventCore(initialState, mode, name, out createdNew); }
private void CreateEventCore(bool initialState, EventResetMode mode, string name, out bool createdNew) { Debug.Assert(name == null); SafeWaitHandle = WaitSubsystem.NewEvent(initialState, mode); createdNew = true; }
public EventWaitHandle(bool initialState, EventResetMode mode, string name) { if ((name != null) && (260 < name.Length)) { throw new ArgumentException(Environment.GetResourceString("Argument_WaitHandleNameTooLong", new object[] { name })); } SafeWaitHandle handle = null; switch (mode) { case EventResetMode.AutoReset: handle = Win32Native.CreateEvent(null, false, initialState, name); break; case EventResetMode.ManualReset: handle = Win32Native.CreateEvent(null, true, initialState, name); break; default: throw new ArgumentException(Environment.GetResourceString("Argument_InvalidFlag", new object[] { name })); } if (handle.IsInvalid) { int errorCode = Marshal.GetLastWin32Error(); handle.SetHandleAsInvalid(); if (((name != null) && (name.Length != 0)) && (6 == errorCode)) { throw new WaitHandleCannotBeOpenedException(Environment.GetResourceString("Threading.WaitHandleCannotBeOpenedException_InvalidHandle", new object[] { name })); } __Error.WinIOError(errorCode, name); } base.SetHandleInternal(handle); }
public void EventWaitHandle_Create_BeyondMaxPathLength() { // GetRandomName prevents name collision when two tests run at the same time string name = GetRandomName() + new string('x', Interop.Kernel32.MAX_PATH); EventWaitHandleSecurity security = GetBasicEventWaitHandleSecurity(); EventResetMode mode = EventResetMode.AutoReset; if (PlatformDetection.IsNetFramework) { Assert.Throws <ArgumentException>(() => { CreateEventWaitHandle( initialState: true, mode, name, security, expectedCreatedNew: true).Dispose(); }); } else { using EventWaitHandle created = CreateAndVerifyEventWaitHandle( initialState: true, mode, name, security, expectedCreatedNew: true); using EventWaitHandle openedByName = EventWaitHandle.OpenExisting(name); Assert.NotNull(openedByName); } }
public void EventWaitHandle_Create_InvalidMode(EventResetMode mode) { if (PlatformDetection.IsNetFramework) { Assert.Throws <ArgumentException>(() => { CreateEventWaitHandle( initialState: true, mode, GetRandomName(), GetBasicEventWaitHandleSecurity(), expectedCreatedNew: true).Dispose(); }); } else { Assert.Throws <ArgumentOutOfRangeException>("mode", () => { CreateEventWaitHandle( initialState: true, mode, GetRandomName(), GetBasicEventWaitHandleSecurity(), expectedCreatedNew: true).Dispose(); }); } }
static public EventWaitHandle CreateWaitHandle(string id, bool initState, EventResetMode resetMode, bool allowEveryone) { //EventResetMode.AutoReset: Set()後,不管有無進入WaitOne(),馬上被自動reset EventWaitHandle eventWaitHandle; bool createNew; if (allowEveryone) { //避免跨Process因權限不足產生WinIOError (Access to the path 'id' is denied.) // create a rule that allows anybody in the "Users" group to synchronise with us //var users = new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null); EventWaitHandleSecurity evhSec = new EventWaitHandleSecurity(); EventWaitHandleRights rights = EventWaitHandleRights.FullControl;// EventWaitHandleRights.Synchronize | EventWaitHandleRights.Modify; EventWaitHandleAccessRule evhAccessRule = new EventWaitHandleAccessRule("Everyone", rights, AccessControlType.Allow); evhSec.AddAccessRule(evhAccessRule); eventWaitHandle = new EventWaitHandle(initState, resetMode, id, out createNew); //eventWaitHandle.SetAccessControl(evhSec); } else { eventWaitHandle = new EventWaitHandle(initState, resetMode, id, out createNew); } return(eventWaitHandle); }
private static void VerifyMode(EventResetMode mode) { if (mode != EventResetMode.AutoReset && mode != EventResetMode.ManualReset) { throw new ArgumentException(SR.Argument_InvalidFlag, nameof(mode)); } }
public void Ctor_NameUsedByOtherSynchronizationPrimitive_Windows(EventResetMode mode) { string name = Guid.NewGuid().ToString("N"); using (Mutex m = new Mutex(false, name)) Assert.Throws <WaitHandleCannotBeOpenedException>(() => new EventWaitHandle(false, mode, name)); }
public EventWaitHandle (bool initialState, EventResetMode mode, string name, out bool createdNew, EventWaitHandleSecurity eventSecurity) { bool manual = IsManualReset (mode); Handle = NativeEventCalls.CreateEvent_internal (manual, initialState, name, out createdNew); }
public EventWaitHandle(bool initialState, EventResetMode mode) { bool created; bool manual = IsManualReset(mode); semaphore = CreateSemaphore(manual, initialState, null, out created); }
public EventWaitHandle(bool initialState, EventResetMode mode, string name) { if(null != name && System.IO.Path.MAX_PATH < name.Length) { throw new ArgumentException(Environment.GetResourceString("Argument_WaitHandleNameTooLong",name)); } Contract.EndContractBlock(); SafeWaitHandle _handle = null; switch(mode) { case EventResetMode.ManualReset: _handle = Win32Native.CreateEvent(null, true, initialState, name); break; case EventResetMode.AutoReset: _handle = Win32Native.CreateEvent(null, false, initialState, name); break; default: throw new ArgumentException(Environment.GetResourceString("Argument_InvalidFlag",name)); }; if (_handle.IsInvalid) { int errorCode = Marshal.GetLastWin32Error(); _handle.SetHandleAsInvalid(); if(null != name && 0 != name.Length && Win32Native.ERROR_INVALID_HANDLE == errorCode) throw new WaitHandleCannotBeOpenedException(Environment.GetResourceString("Threading.WaitHandleCannotBeOpenedException_InvalidHandle",name)); __Error.WinIOError(errorCode, name); } SetHandleInternal(_handle); }
public EventWaitHandle(bool initialState, EventResetMode mode, string name) { bool created; Handle = NativeEventCalls.CreateEvent_internal((mode == EventResetMode.ManualReset), initialState, name, out created); }
public EventWaitHandle(bool initialState, EventResetMode mode) { bool created; bool manual = IsManualReset(mode); Handle = NativeEventCalls.CreateEvent_internal(manual, initialState, null, out created); }
public EventWaitHandle(bool initialState, EventResetMode mode, string name) { if ((name != null) && (260 < name.Length)) { throw new ArgumentException(Environment.GetResourceString("Argument_WaitHandleNameTooLong", new object[] { name })); } SafeWaitHandle handle = null; switch (mode) { case EventResetMode.AutoReset: handle = Win32Native.CreateEvent(null, false, initialState, name); break; case EventResetMode.ManualReset: handle = Win32Native.CreateEvent(null, true, initialState, name); break; default: throw new ArgumentException(Environment.GetResourceString("Argument_InvalidFlag", new object[] { name })); } if (handle.IsInvalid) { int errorCode = Marshal.GetLastWin32Error(); handle.SetHandleAsInvalid(); if (((name != null) && (name.Length != 0)) && (6 == errorCode)) { throw new WaitHandleCannotBeOpenedException(Environment.GetResourceString("Threading.WaitHandleCannotBeOpenedException_InvalidHandle", new object[] { name })); } __Error.WinIOError(errorCode, ""); } base.SetHandleInternal(handle); }
private void CreateEventCore(bool initialState, EventResetMode mode, string?name, out bool createdNew) { #if !PLATFORM_WINDOWS if (name != null) { throw new PlatformNotSupportedException(SR.PlatformNotSupported_NamedSynchronizationPrimitives); } #endif uint eventFlags = initialState ? Interop.Kernel32.CREATE_EVENT_INITIAL_SET : 0; if (mode == EventResetMode.ManualReset) { eventFlags |= (uint)Interop.Kernel32.CREATE_EVENT_MANUAL_RESET; } SafeWaitHandle handle = Interop.Kernel32.CreateEventEx(IntPtr.Zero, name, eventFlags, AccessRights); int errorCode = Marshal.GetLastWin32Error(); if (handle.IsInvalid) { handle.SetHandleAsInvalid(); if (!string.IsNullOrEmpty(name) && errorCode == Interop.Errors.ERROR_INVALID_HANDLE) { throw new WaitHandleCannotBeOpenedException(SR.Format(SR.Threading_WaitHandleCannotBeOpenedException_InvalidHandle, name)); } throw Win32Marshal.GetExceptionForWin32Error(errorCode, name); } createdNew = errorCode != Interop.Errors.ERROR_ALREADY_EXISTS; SafeWaitHandle = handle; }
public EventWaitHandle(bool initialState, EventResetMode mode) { VerifyMode(mode); bool createdNew; CreateEventCore(initialState, mode, null, out createdNew); }
private bool IsManualReset(EventResetMode mode) { if (mode < EventResetMode.AutoReset || mode > EventResetMode.ManualReset) { throw new ArgumentException("mode"); } return(mode == EventResetMode.ManualReset); }
static bool IsManualReset(EventResetMode mode) { if ((mode < EventResetMode.AutoReset) || (mode > EventResetMode.ManualReset)) { throw new ArgumentException("mode"); } return(mode == EventResetMode.ManualReset); }
private EventWaitHandle CreateEventWaitHandle(bool initialState, EventResetMode mode, string name, EventWaitHandleSecurity expectedSecurity, bool expectedCreatedNew) { EventWaitHandle handle = EventWaitHandleAcl.Create(initialState, mode, name, out bool createdNew, expectedSecurity); Assert.NotNull(handle); Assert.Equal(expectedCreatedNew, createdNew); return(handle); }
public static EventWaitHandle Create( bool initialState, EventResetMode mode, string?name, out bool createdNew, EventWaitHandleSecurity?eventSecurity) { return(new EventWaitHandle(initialState, mode, name, out createdNew, eventSecurity)); }
public EventWaitHandle(bool initialState, EventResetMode mode, string?name, out bool createdNew) { if (mode != EventResetMode.AutoReset && mode != EventResetMode.ManualReset) { throw new ArgumentException(SR.Argument_InvalidFlag, nameof(mode)); } CreateEventCore(initialState, mode, name, out createdNew); }
/// <summary> /// Initializes a new instance of the <see cref="EventWaitHandleLocker"/> class using a /// co-initialized instance of the <see cref="EventWaitHandle"/> class used as the /// wait handle, specifying whether the wait handle is initially signaled if created /// as a result of this call, whether it resets automatically or manually, the name /// of a system synchronization event, and a Boolean variable whose value after the /// call indicates whether the named system event was created. /// </summary> /// <param name="initialState">Specify <c>true</c> to set the initial state to signaled /// if the named event is created as a result of this call; <c>false</c> to set it to /// nonsignaled.</param> /// <param name="mode">One of the <see cref="EventResetMode"/> values /// that determines whether the event resets automatically or manually.</param> /// <param name="name">The name of a system-wide synchronization event.</param> /// <returns></returns> public static EventWaitHandleLocker MakeWithEventHandle(bool initialState, EventResetMode mode, string name) { var eventWaitHandle = new EventWaitHandle(initialState, mode, name); var instance = new EventWaitHandleLocker(eventWaitHandle, mode == EventResetMode.AutoReset); return(instance); }
/// <summary> /// Close any open handles with <paramref name="name"/> and open a new one. /// </summary> /// <param name="name">The handle name.</param> /// <param name="initialState">Initial state.</param> /// <param name="mode">The mode.</param> /// <returns>The new EventWaitHandle created.</returns> public static EventWaitHandle OpenOrCreate(string name, bool initialState, EventResetMode mode) { try { EventWaitHandle.OpenExisting(name).Close(); } catch (WaitHandleCannotBeOpenedException) { } return(new EventWaitHandle(initialState, mode, name)); }
/// <summary> /// Close any open handles with <paramref name="name"/> and open a new one. /// </summary> /// <param name="name">The handle name.</param> /// <param name="initialState">Initial state.</param> /// <param name="mode">The mode.</param> /// <returns>The new EventWaitHandle created.</returns> public static EventWaitHandle OpenOrCreate(string name, bool initialState, EventResetMode mode) { try { EventWaitHandle.OpenExisting(name).Close(); } catch (WaitHandleCannotBeOpenedException) { } return new EventWaitHandle(initialState, mode, name); }
private void CreateEventCore(bool initialState, EventResetMode mode, string?name, out bool createdNew) { if (name != null) { throw new PlatformNotSupportedException(SR.PlatformNotSupported_NamedSynchronizationPrimitives); } SafeWaitHandle = WaitSubsystem.NewEvent(initialState, mode); createdNew = true; }
public EventWaitHandle(bool initialState, EventResetMode mode, string name, out bool createdNew) { IntPtr ptr = CreateEvent(IntPtr.Zero, mode == EventResetMode.ManualReset, initialState, name); if (ptr.Equals(IntPtr.Zero)) { throw new ApplicationException("Cannot create " + name); } createdNew = Marshal.GetLastWin32Error() != 0xb7; Handle = ptr; }
[System.Security.SecurityCritical] // auto-generated_required public unsafe EventWaitHandle(bool initialState, EventResetMode mode, string name, out bool createdNew, EventWaitHandleSecurity eventSecurity) { if (null != name && System.IO.Path.MAX_PATH < name.Length) { throw new ArgumentException(Environment.GetResourceString("Argument_WaitHandleNameTooLong", name)); } Contract.EndContractBlock(); Win32Native.SECURITY_ATTRIBUTES secAttrs = null; #if FEATURE_MACL // For ACL's, get the security descriptor from the EventWaitHandleSecurity. if (eventSecurity != null) { secAttrs = new Win32Native.SECURITY_ATTRIBUTES(); secAttrs.nLength = (int)Marshal.SizeOf(secAttrs); byte[] sd = eventSecurity.GetSecurityDescriptorBinaryForm(); byte * pSecDescriptor = stackalloc byte[sd.Length]; Buffer.Memcpy(pSecDescriptor, 0, sd, 0, sd.Length); secAttrs.pSecurityDescriptor = pSecDescriptor; } #endif SafeWaitHandle _handle = null; Boolean isManualReset; switch (mode) { case EventResetMode.ManualReset: isManualReset = true; break; case EventResetMode.AutoReset: isManualReset = false; break; default: throw new ArgumentException(Environment.GetResourceString("Argument_InvalidFlag", name)); } ; _handle = Win32Native.CreateEvent(secAttrs, isManualReset, initialState, name); int errorCode = Marshal.GetLastWin32Error(); if (_handle.IsInvalid) { _handle.SetHandleAsInvalid(); if (null != name && 0 != name.Length && Win32Native.ERROR_INVALID_HANDLE == errorCode) { throw new WaitHandleCannotBeOpenedException(Environment.GetResourceString("Threading.WaitHandleCannotBeOpenedException_InvalidHandle", name)); } __Error.WinIOError(errorCode, name); } createdNew = errorCode != Win32Native.ERROR_ALREADY_EXISTS; SetHandleInternal(_handle); }
/// <summary> /// Initializes a newly created <see cref="EventWaitHandle"/> object, specifying whether the wait handle is initially signaled, whether it resets automatically or manually, the name of a system synchronization event, and a bool variable whose value after the call indicates whether the named system event was created. /// </summary> /// <param name="initialState">true to set the initial state to signaled, false to set it to nonsignaled.</param> /// <param name="mode">An Threading.EventResetMode value that determines whether the event resets automatically or manually.</param> /// <param name="name">The name of a system-wide synchronization event.</param> /// <param name="createdNew">When this method returns, contains true if the calling thread was granted initial ownership of the named system event; otherwise, false. This parameter is passed uninitialized.</param> public EventWaitHandle(bool initialState, EventResetMode mode, string name, out bool createdNew) { IntPtr h = NativeMethods.CreateEvent(IntPtr.Zero, mode == EventResetMode.ManualReset, initialState, name); if (h.Equals(IntPtr.Zero)) { throw new ApplicationException("Cannot create " + name); } createdNew = (Marshal.GetLastWin32Error() == NativeMethods.ERROR_ALREADY_EXISTS); this.Handle = h; }
/// <summary> /// Default Constructor /// </summary> /// <param name="eventName">name of the event to distinguish</param> public EventEx(String eventName = null) : base() { m_eventResetMode=EventResetMode.AutoReset; m_isInitialRaised=true; m_name=eventName; if (m_name == null) m_event = new EventWaitHandle(m_isInitialRaised, m_eventResetMode); else m_event = new EventWaitHandle(m_isInitialRaised, m_eventResetMode, m_name); }
public EventWaitHandle(bool initialState, EventResetMode mode, string name, out bool createdNew) { IntPtr ptr = CreateEvent(IntPtr.Zero, mode == EventResetMode.ManualReset, initialState, name); if (ptr.Equals(IntPtr.Zero)) { throw new ApplicationException("Cannot create " + name); } createdNew = Marshal.GetLastWin32Error() != 0xb7; Handle = ptr; }
public unsafe EventWaitHandle(bool initialState, EventResetMode mode, string name, out bool createdNew, EventWaitHandleSecurity eventSecurity) { if (name != null && 260 < name.Length) { throw new ArgumentException(Environment.GetResourceString("Argument_WaitHandleNameTooLong", new object[] { name })); } Win32Native.SECURITY_ATTRIBUTES security_ATTRIBUTES = null; if (eventSecurity != null) { security_ATTRIBUTES = new Win32Native.SECURITY_ATTRIBUTES(); security_ATTRIBUTES.nLength = Marshal.SizeOf <Win32Native.SECURITY_ATTRIBUTES>(security_ATTRIBUTES); byte[] securityDescriptorBinaryForm = eventSecurity.GetSecurityDescriptorBinaryForm(); byte * ptr = stackalloc byte[checked (unchecked ((UIntPtr)securityDescriptorBinaryForm.Length) * 1)]; Buffer.Memcpy(ptr, 0, securityDescriptorBinaryForm, 0, securityDescriptorBinaryForm.Length); security_ATTRIBUTES.pSecurityDescriptor = ptr; } bool isManualReset; if (mode != EventResetMode.AutoReset) { if (mode != EventResetMode.ManualReset) { throw new ArgumentException(Environment.GetResourceString("Argument_InvalidFlag", new object[] { name })); } isManualReset = true; } else { isManualReset = false; } SafeWaitHandle safeWaitHandle = Win32Native.CreateEvent(security_ATTRIBUTES, isManualReset, initialState, name); int lastWin32Error = Marshal.GetLastWin32Error(); if (safeWaitHandle.IsInvalid) { safeWaitHandle.SetHandleAsInvalid(); if (name != null && name.Length != 0 && 6 == lastWin32Error) { throw new WaitHandleCannotBeOpenedException(Environment.GetResourceString("Threading.WaitHandleCannotBeOpenedException_InvalidHandle", new object[] { name })); } __Error.WinIOError(lastWin32Error, name); } createdNew = (lastWin32Error != 183); base.SetHandleInternal(safeWaitHandle); }
public GlobalNamedEvent(string name, EventResetMode resetMode = EventResetMode.AutoReset) { try { m_globalEvent = EventWaitHandle.OpenExisting(name); } catch (WaitHandleCannotBeOpenedException) { m_globalEvent = new EventWaitHandle(false, resetMode, name); } }
public void EventWaitHandle_Create_SpecificParameters(bool initialState, EventResetMode mode, EventWaitHandleRights rights, AccessControlType accessControl) { EventWaitHandleSecurity security = GetEventWaitHandleSecurity(WellKnownSidType.BuiltinUsersSid, rights, accessControl); CreateAndVerifyEventWaitHandle( initialState, mode, GetRandomName(), security, expectedCreatedNew: true).Dispose(); }
/// <summary> /// Default Constructor /// </summary> /// <param name="eventName">name of the event to distinguish</param> public EventEx() : base() { m_eventResetMode = EventResetMode.AutoReset; m_isInitialRaised=true; if (m_eventResetMode == EventResetMode.AutoReset) m_event = new AutoResetEvent(m_isInitialRaised); else { m_event = new ManualResetEvent(m_isInitialRaised); } }
public EventWaitHandleEx(bool initialState, EventResetMode mode, string name, out bool createdNew) { var handle = NativeMethods.CreateEvent(IntPtr.Zero, mode == EventResetMode.ManualReset, initialState, name); if (handle == IntPtr.Zero) { throw new Win32Exception(Marshal.GetLastWin32Error()); } createdNew = Marshal.GetLastWin32Error() != ERROR_ALREADY_EXISTS; Handle = handle; }
public static bool Create(string name, EventResetMode mode, out EventWaitHandle signal) { var users = new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null); var rule = new EventWaitHandleAccessRule(users, EventWaitHandleRights.Synchronize | EventWaitHandleRights.Modify, AccessControlType.Allow); var security = new EventWaitHandleSecurity(); security.AddAccessRule(rule); bool created; signal = new EventWaitHandle(false, mode, @"Global\" + name, out created, security); return created; }
public void Ctor_StateModeNameCreatedNew_Windows(bool initialState, EventResetMode mode) { string name = Guid.NewGuid().ToString("N"); bool createdNew; using (var ewh = new EventWaitHandle(false, EventResetMode.AutoReset, name, out createdNew)) { Assert.True(createdNew); using (new EventWaitHandle(false, EventResetMode.AutoReset, name, out createdNew)) { Assert.False(createdNew); } } }
public unsafe EventWaitHandle(bool initialState, EventResetMode mode, string name, out bool createdNew, EventWaitHandleSecurity eventSecurity) { bool flag; if ((name != null) && (260 < name.Length)) { throw new ArgumentException(Environment.GetResourceString("Argument_WaitHandleNameTooLong", new object[] { name })); } Win32Native.SECURITY_ATTRIBUTES structure = null; if (eventSecurity != null) { structure = new Win32Native.SECURITY_ATTRIBUTES { nLength = Marshal.SizeOf(structure) }; byte[] securityDescriptorBinaryForm = eventSecurity.GetSecurityDescriptorBinaryForm(); byte* pDest = stackalloc byte[1 * securityDescriptorBinaryForm.Length]; Buffer.memcpy(securityDescriptorBinaryForm, 0, pDest, 0, securityDescriptorBinaryForm.Length); structure.pSecurityDescriptor = pDest; } SafeWaitHandle handle = null; switch (mode) { case EventResetMode.AutoReset: flag = false; break; case EventResetMode.ManualReset: flag = true; break; default: throw new ArgumentException(Environment.GetResourceString("Argument_InvalidFlag", new object[] { name })); } handle = Win32Native.CreateEvent(structure, flag, initialState, name); int errorCode = Marshal.GetLastWin32Error(); if (handle.IsInvalid) { handle.SetHandleAsInvalid(); if (((name != null) && (name.Length != 0)) && (6 == errorCode)) { throw new WaitHandleCannotBeOpenedException(Environment.GetResourceString("Threading.WaitHandleCannotBeOpenedException_InvalidHandle", new object[] { name })); } __Error.WinIOError(errorCode, name); } createdNew = errorCode != 0xb7; base.SetHandleInternal(handle); }
public EventWaitHandle(bool initialState, EventResetMode mode, string name) { if (null != name) { if (((int)Interop.Constants.MaxPath) < name.Length) { throw new ArgumentException(SR.Format(SR.Argument_WaitHandleNameTooLong, name)); } } Contract.EndContractBlock(); uint eventFlags = initialState ? (uint)Interop.Constants.CreateEventInitialSet : 0; IntPtr unsafeHandle; switch (mode) { case EventResetMode.ManualReset: eventFlags |= (uint)Interop.Constants.CreateEventManualReset; break; case EventResetMode.AutoReset: break; default: throw new ArgumentException(SR.Format(SR.Argument_InvalidFlag, name)); }; unsafeHandle = Interop.mincore.CreateEventEx(IntPtr.Zero, name, eventFlags, (uint)Interop.Constants.EventAllAccess); int errorCode = (int)Interop.mincore.GetLastError(); SafeWaitHandle _handle = new SafeWaitHandle(unsafeHandle, true); if (_handle.IsInvalid) { _handle.SetHandleAsInvalid(); if (null != name && 0 != name.Length && Interop.mincore.Errors.ERROR_INVALID_HANDLE == errorCode) throw new WaitHandleCannotBeOpenedException(SR.Format(SR.Threading_WaitHandleCannotBeOpenedException_InvalidHandle, name)); throw ExceptionFromCreationError(errorCode, name); } SafeWaitHandle = _handle; }
public void PingPong(EventResetMode mode) { // Create names for the two events string outboundName = Guid.NewGuid().ToString("N"); string inboundName = Guid.NewGuid().ToString("N"); // Create the two events and the other process with which to synchronize using (var inbound = new EventWaitHandle(true, mode, inboundName)) using (var outbound = new EventWaitHandle(false, mode, outboundName)) using (var remote = RemoteInvoke(PingPong_OtherProcess, mode.ToString(), outboundName, inboundName)) { // Repeatedly wait for one event and then set the other for (int i = 0; i < 10; i++) { Assert.True(inbound.WaitOne(FailWaitTimeoutMilliseconds)); if (mode == EventResetMode.ManualReset) { inbound.Reset(); } outbound.Set(); } } }
public EventWaitHandle(bool initialState, EventResetMode mode, string nameout , System.Boolean& createdNew) {}
public EventWaitHandle(bool initialState, EventResetMode mode, string name) {}
public EventWaitHandle (bool initialState, EventResetMode mode) { bool created; bool manual = IsManualReset (mode); Handle = NativeEventCalls.CreateEvent_internal (manual, initialState, null, out created); }
public void Ctor_NameUsedByOtherSynchronizationPrimitive_Windows(EventResetMode mode) { string name = Guid.NewGuid().ToString("N"); using (Mutex m = new Mutex(false, name)) Assert.Throws<WaitHandleCannotBeOpenedException>(() => new EventWaitHandle(false, mode, name)); }
public XEngineEventWaitHandle(bool initialState, EventResetMode mode) : base(initialState, mode) {}
public void Ctor_StateMode(bool initialState, EventResetMode mode) { using (var ewh = new EventWaitHandle(initialState, mode)) Assert.Equal(initialState, ewh.WaitOne(0)); }
private bool IsManualReset (EventResetMode mode) { if ((mode < EventResetMode.AutoReset) || (mode > EventResetMode.ManualReset)) throw new ArgumentException ("mode"); return (mode == EventResetMode.ManualReset); }
/// <summary> /// Default Constructor /// </summary> /// <param name="isInitialRaised">flag to raise the event on creation</param> /// <param name="eventResetMode">EventResetMode</param> /// <param name="eventName">name of the event to distinguish</param> public EventEx(bool isInitialRaised, EventResetMode eventResetMode, String eventName = null):base() { m_eventResetMode=eventResetMode; m_isInitialRaised=isInitialRaised; m_name=eventName; if(m_name==null) m_event = new EventWaitHandle(m_isInitialRaised, m_eventResetMode); else m_event=new EventWaitHandle(m_isInitialRaised,m_eventResetMode,m_name); }
public EventWaitHandle(bool initialState, EventResetMode mode, string name, out bool createdNew) : this(initialState, mode, name, out createdNew, null) { }
public EventWaitHandle(bool initialState, EventResetMode mode, string nameout , System.Boolean& createdNew, System.Security.AccessControl.EventWaitHandleSecurity eventSecurity) {}
public EventWaitHandle(bool initialState, EventResetMode mode) : this(initialState, mode, null) { }
public EventWaitHandle (bool initialState, EventResetMode mode, string name, out bool createdNew, EventWaitHandleSecurity eventSecurity) { throw new NotSupportedException (); }
public EventWaitHandle (bool initialState, EventResetMode mode, string name) { throw new NotSupportedException (); }
/// <summary> /// Default Copy Constructor /// </summary> /// <param name="b">the object to copy from</param> public EventEx(EventEx b):base(b) { m_isInitialRaised=b.m_isInitialRaised; m_name=b.m_name; m_eventResetMode=b.m_eventResetMode; if (m_name == null) m_event = new EventWaitHandle(m_isInitialRaised, m_eventResetMode); else m_event = new EventWaitHandle(m_isInitialRaised, m_eventResetMode, m_name); }
public AsyncWaitHandle(EventResetMode resetMode) { this.resetMode = resetMode; this.syncObject = new object(); }
public unsafe EventWaitHandle(bool initialState, EventResetMode mode, string name, out bool createdNew, EventWaitHandleSecurity eventSecurity) { if(null != name && System.IO.Path.MAX_PATH < name.Length) { throw new ArgumentException(Environment.GetResourceString("Argument_WaitHandleNameTooLong",name)); } Contract.EndContractBlock(); Win32Native.SECURITY_ATTRIBUTES secAttrs = null; #if FEATURE_MACL // For ACL's, get the security descriptor from the EventWaitHandleSecurity. if (eventSecurity != null) { secAttrs = new Win32Native.SECURITY_ATTRIBUTES(); secAttrs.nLength = (int)Marshal.SizeOf(secAttrs); byte[] sd = eventSecurity.GetSecurityDescriptorBinaryForm(); byte* pSecDescriptor = stackalloc byte[sd.Length]; Buffer.Memcpy(pSecDescriptor, 0, sd, 0, sd.Length); secAttrs.pSecurityDescriptor = pSecDescriptor; } #endif SafeWaitHandle _handle = null; Boolean isManualReset; switch(mode) { case EventResetMode.ManualReset: isManualReset = true; break; case EventResetMode.AutoReset: isManualReset = false; break; default: throw new ArgumentException(Environment.GetResourceString("Argument_InvalidFlag",name)); }; _handle = Win32Native.CreateEvent(secAttrs, isManualReset, initialState, name); int errorCode = Marshal.GetLastWin32Error(); if (_handle.IsInvalid) { _handle.SetHandleAsInvalid(); if(null != name && 0 != name.Length && Win32Native.ERROR_INVALID_HANDLE == errorCode) throw new WaitHandleCannotBeOpenedException(Environment.GetResourceString("Threading.WaitHandleCannotBeOpenedException_InvalidHandle",name)); __Error.WinIOError(errorCode, name); } createdNew = errorCode != Win32Native.ERROR_ALREADY_EXISTS; SetHandleInternal(_handle); }