Ejemplo n.º 1
0
        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);
        }
Ejemplo n.º 2
0
        public EventWaitHandle(bool initialState, EventResetMode mode,
                               string name, out bool createdNew)
        {
            bool manual = IsManualReset(mode);

            Handle = NativeEventCalls.CreateEvent_internal(manual, initialState, name, out createdNew);
        }
Ejemplo n.º 3
0
        /// <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);
        }
Ejemplo n.º 4
0
		private static bool IsManualReset (EventResetMode mode)
		{
			if ((mode < EventResetMode.AutoReset) || (mode > EventResetMode.ManualReset)) {
				throw new ArgumentException ("mode");
			}
			return mode == EventResetMode.ManualReset;
		}
Ejemplo n.º 5
0
        public EventWaitHandle(bool initialState, EventResetMode mode, string name, out bool createdNew)
        {
            VerifyNameForCreate(name);
            VerifyMode(mode);

            CreateEventCore(initialState, mode, name, out createdNew);
        }
Ejemplo n.º 6
0
        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);
        }
Ejemplo n.º 8
0
        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);
            }
        }
Ejemplo n.º 9
0
 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();
         });
     }
 }
Ejemplo n.º 10
0
        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);
        }
Ejemplo n.º 11
0
 private static void VerifyMode(EventResetMode mode)
 {
     if (mode != EventResetMode.AutoReset && mode != EventResetMode.ManualReset)
     {
         throw new ArgumentException(SR.Argument_InvalidFlag, nameof(mode));
     }
 }
Ejemplo n.º 12
0
        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));
        }
Ejemplo n.º 13
0
		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);
		}
Ejemplo n.º 14
0
        public EventWaitHandle(bool initialState, EventResetMode mode)
        {
            bool created;
            bool manual = IsManualReset(mode);

            semaphore = CreateSemaphore(manual, initialState, null, out created);
        }
Ejemplo n.º 15
0
        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);
        }
Ejemplo n.º 16
0
        public EventWaitHandle(bool initialState, EventResetMode mode,
                               string name)
        {
            bool created;

            Handle = NativeEventCalls.CreateEvent_internal((mode == EventResetMode.ManualReset), initialState, name, out created);
        }
Ejemplo n.º 17
0
        public EventWaitHandle(bool initialState, EventResetMode mode)
        {
            bool created;
            bool manual = IsManualReset(mode);

            Handle = NativeEventCalls.CreateEvent_internal(manual, initialState, null, out created);
        }
Ejemplo n.º 18
0
        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;
        }
Ejemplo n.º 20
0
        public EventWaitHandle(bool initialState, EventResetMode mode)
        {
            VerifyMode(mode);

            bool createdNew;

            CreateEventCore(initialState, mode, null, out createdNew);
        }
Ejemplo n.º 21
0
 private bool IsManualReset(EventResetMode mode)
 {
     if (mode < EventResetMode.AutoReset || mode > EventResetMode.ManualReset)
     {
         throw new ArgumentException("mode");
     }
     return(mode == EventResetMode.ManualReset);
 }
Ejemplo n.º 22
0
 static bool IsManualReset(EventResetMode mode)
 {
     if ((mode < EventResetMode.AutoReset) || (mode > EventResetMode.ManualReset))
     {
         throw new ArgumentException("mode");
     }
     return(mode == EventResetMode.ManualReset);
 }
Ejemplo n.º 23
0
        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);
        }
Ejemplo n.º 24
0
 public static EventWaitHandle Create(
     bool initialState,
     EventResetMode mode,
     string?name,
     out bool createdNew,
     EventWaitHandleSecurity?eventSecurity)
 {
     return(new EventWaitHandle(initialState, mode, name, out createdNew, eventSecurity));
 }
Ejemplo n.º 25
0
        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);
        }
Ejemplo n.º 26
0
        /// <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);
        }
Ejemplo n.º 27
0
        /// <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));
        }
Ejemplo n.º 28
0
        /// <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);
        }
Ejemplo n.º 29
0
        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;
        }
Ejemplo n.º 30
0
 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;
 }
Ejemplo n.º 31
0
        [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);
        }
Ejemplo n.º 32
0
        /// <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;
        }
Ejemplo n.º 33
0
        /// <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);
        }
Ejemplo n.º 36
0
 public GlobalNamedEvent(string name, EventResetMode resetMode = EventResetMode.AutoReset)
 {
     try
     {
         m_globalEvent = EventWaitHandle.OpenExisting(name);
     }
     catch (WaitHandleCannotBeOpenedException)
     {
         m_globalEvent = new EventWaitHandle(false, resetMode, name);
     }
 }
Ejemplo n.º 37
0
        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();
        }
Ejemplo n.º 38
0
        /// <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);
            }
        }
Ejemplo n.º 39
0
        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;
        }
Ejemplo n.º 41
0
 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);
         }
     }
 }
Ejemplo n.º 42
0
        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);
        }
Ejemplo n.º 43
0
        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;
        }
Ejemplo n.º 44
0
        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) {}
Ejemplo n.º 47
0
		public EventWaitHandle (bool initialState, EventResetMode mode)
		{
			bool created;
			bool manual = IsManualReset (mode);
			Handle = NativeEventCalls.CreateEvent_internal (manual, initialState, null, out created);
		}
Ejemplo n.º 48
0
 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));
 }
Ejemplo n.º 49
0
 public XEngineEventWaitHandle(bool initialState, EventResetMode mode) : base(initialState, mode) {}
Ejemplo n.º 50
0
 public void Ctor_StateMode(bool initialState, EventResetMode mode)
 {
     using (var ewh = new EventWaitHandle(initialState, mode))
         Assert.Equal(initialState, ewh.WaitOne(0));
 }
Ejemplo n.º 51
0
		private bool IsManualReset (EventResetMode mode)
		{
			if ((mode < EventResetMode.AutoReset) || (mode > EventResetMode.ManualReset))
				throw new ArgumentException ("mode");
			return (mode == EventResetMode.ManualReset);
		}
Ejemplo n.º 52
0
        /// <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);
        }
Ejemplo n.º 53
0
 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) {}
Ejemplo n.º 55
0
 public EventWaitHandle(bool initialState, EventResetMode mode) : this(initialState, mode, null)
 {
 }
Ejemplo n.º 56
0
		public EventWaitHandle (bool initialState, EventResetMode mode,
		                        string name, out bool createdNew,
		                        EventWaitHandleSecurity eventSecurity)
		{
			throw new NotSupportedException ();
		}
Ejemplo n.º 57
0
		public EventWaitHandle (bool initialState, EventResetMode mode, string name)
		{
			throw new NotSupportedException ();
		}
Ejemplo n.º 58
0
        /// <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);
        }
Ejemplo n.º 59
0
 public AsyncWaitHandle(EventResetMode resetMode)
 {
     this.resetMode = resetMode;
     this.syncObject = new object();
 }
Ejemplo n.º 60
0
        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);
        }