Simplify mutex/semaphore/event creation paths for APIs without a name argument

Koundinya Veluri · Koundinya Veluri · commit 4714795a37b6 · 2025-02-19T09:49:57.000-08:00
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Threading/Mutex.CoreCLR.Unix.cs b/src/coreclr/System.Private.CoreLib/src/System/Threading/Mutex.CoreCLR.Unix.cs
@@ -14,6 +14,25 @@ namespace System.Threading
     /// </summary>
     public sealed partial class Mutex : WaitHandle
     {
+        private unsafe void CreateMutexCore(bool initiallyOwned)
+        {
+            SafeWaitHandle handle =
+                CreateMutex(
+                    initiallyOwned,
+                    name: null,
+                    currentUserOnly: false,
+                    systemCallErrors: null,
+                    systemCallErrorsBufferSize: 0);
+            if (handle.IsInvalid)
+            {
+                int errorCode = Marshal.GetLastPInvokeError();
+                handle.SetHandleAsInvalid();
+                throw Win32Marshal.GetExceptionForWin32Error(errorCode);
+            }
+
+            SafeWaitHandle = handle;
+        }
+
         private void CreateMutexCore(
             bool initiallyOwned,
             string? name,
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/EventWaitHandle.Unix.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/EventWaitHandle.Unix.cs
@@ -10,6 +10,12 @@ namespace System.Threading
 {
     public partial class EventWaitHandle
     {
+        private void CreateEventCore(bool initialState, EventResetMode mode)
+        {
+            ValidateMode(mode);
+            SafeWaitHandle = WaitSubsystem.NewEvent(initialState, mode);
+        }
+
 #pragma warning disable IDE0060 // Unused parameter
         private void CreateEventCore(
             bool initialState,
@@ -18,10 +24,7 @@ private void CreateEventCore(
             NamedWaitHandleOptionsInternal options,
             out bool createdNew)
         {
-            if (mode != EventResetMode.AutoReset && mode != EventResetMode.ManualReset)
-            {
-                throw new ArgumentException(SR.Argument_InvalidFlag, nameof(mode));
-            }
+            ValidateMode(mode);
 
             if (name != null)
             {
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/EventWaitHandle.Windows.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/EventWaitHandle.Windows.cs
@@ -22,17 +22,32 @@ private EventWaitHandle(SafeWaitHandle handle)
             SafeWaitHandle = handle;
         }
 
+        private unsafe void CreateEventCore(bool initialState, EventResetMode mode)
+        {
+            ValidateMode(mode);
+
+            uint flags = initialState ? Interop.Kernel32.CREATE_EVENT_INITIAL_SET : 0;
+            if (mode == EventResetMode.ManualReset)
+                flags |= Interop.Kernel32.CREATE_EVENT_MANUAL_RESET;
+            SafeWaitHandle handle = Interop.Kernel32.CreateEventEx(lpSecurityAttributes: 0, name: null, flags, AccessRights);
+            if (handle.IsInvalid)
+            {
+                int errorCode = Marshal.GetLastPInvokeError();
+                handle.SetHandleAsInvalid();
+                throw Win32Marshal.GetExceptionForWin32Error(errorCode);
+            }
+
+            SafeWaitHandle = handle;
+        }
+
         private unsafe void CreateEventCore(
             bool initialState,
             EventResetMode mode,
             string? name,
             NamedWaitHandleOptionsInternal options,
             out bool createdNew)
         {
-            if (mode != EventResetMode.AutoReset && mode != EventResetMode.ManualReset)
-            {
-                throw new ArgumentException(SR.Argument_InvalidFlag, nameof(mode));
-            }
+            ValidateMode(mode);
 
 #if !TARGET_WINDOWS
             if (name != null)
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/EventWaitHandle.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/EventWaitHandle.cs
@@ -12,7 +12,7 @@ public partial class EventWaitHandle : WaitHandle
     {
         public EventWaitHandle(bool initialState, EventResetMode mode)
         {
-            CreateEventCore(initialState, mode, name: null, options: default, out _);
+            CreateEventCore(initialState, mode);
         }
 
         /// <summary>
@@ -64,6 +64,14 @@ public EventWaitHandle(bool initialState, EventResetMode mode, string? name, out
             CreateEventCore(initialState, mode, name, options: default, out createdNew);
         }
 
+        private static void ValidateMode(EventResetMode mode)
+        {
+            if (mode != EventResetMode.AutoReset && mode != EventResetMode.ManualReset)
+            {
+                throw new ArgumentException(SR.Argument_InvalidFlag, nameof(mode));
+            }
+        }
+
         /// <summary>
         /// Opens an existing named event.
         /// </summary>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Mutex.Unix.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Mutex.Unix.cs
@@ -10,6 +10,8 @@ namespace System.Threading
 {
     public sealed partial class Mutex
     {
+        private void CreateMutexCore(bool initiallyOwned) => SafeWaitHandle = WaitSubsystem.NewMutex(initiallyOwned);
+
         private void CreateMutexCore(
             bool initiallyOwned,
             string? name,
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Mutex.Windows.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Mutex.Windows.cs
@@ -19,6 +19,20 @@ public sealed partial class Mutex : WaitHandle
         private const int CurrentUserOnlyAceRights =
             Interop.Kernel32.STANDARD_RIGHTS_REQUIRED | Interop.Kernel32.SYNCHRONIZE | Interop.Kernel32.MUTEX_MODIFY_STATE;
 
+        private void CreateMutexCore(bool initiallyOwned)
+        {
+            uint flags = initiallyOwned ? Interop.Kernel32.CREATE_MUTEX_INITIAL_OWNER : 0;
+            SafeWaitHandle handle = Interop.Kernel32.CreateMutexEx(lpMutexAttributes: 0, name: null, flags, AccessRights);
+            if (handle.IsInvalid)
+            {
+                int errorCode = Marshal.GetLastPInvokeError();
+                handle.SetHandleAsInvalid();
+                throw Win32Marshal.GetExceptionForWin32Error(errorCode);
+            }
+
+            SafeWaitHandle = handle;
+        }
+
         private unsafe void CreateMutexCore(
             bool initiallyOwned,
             string? name,
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Mutex.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Mutex.cs
@@ -82,12 +82,12 @@ public Mutex(string? name, NamedWaitHandleOptions options)
 
         public Mutex(bool initiallyOwned)
         {
-            CreateMutexCore(initiallyOwned, name: null, options: default, createdNew: out _);
+            CreateMutexCore(initiallyOwned);
         }
 
         public Mutex()
         {
-            CreateMutexCore(initiallyOwned: false, name: null, options: default, createdNew: out _);
+            CreateMutexCore(initiallyOwned: false);
         }
 
         private Mutex(SafeWaitHandle handle)
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Semaphore.Unix.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Semaphore.Unix.cs
@@ -10,6 +10,12 @@ namespace System.Threading
 {
     public sealed partial class Semaphore
     {
+        private void CreateSemaphoreCore(int initialCount, int maximumCount)
+        {
+            ValidateArguments(initialCount, maximumCount);
+            SafeWaitHandle = WaitSubsystem.NewSemaphore(initialCount, maximumCount);
+        }
+
 #pragma warning disable IDE0060 // Unused parameter
         private void CreateSemaphoreCore(
             int initialCount,
@@ -18,13 +24,7 @@ private void CreateSemaphoreCore(
             NamedWaitHandleOptionsInternal options,
             out bool createdNew)
         {
-            ArgumentOutOfRangeException.ThrowIfNegative(initialCount);
-            ArgumentOutOfRangeException.ThrowIfNegativeOrZero(maximumCount);
-
-            if (initialCount > maximumCount)
-            {
-                throw new ArgumentException(SR.Argument_SemaphoreInitialMaximum);
-            }
+            ValidateArguments(initialCount, maximumCount);
 
             if (name != null)
             {
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Semaphore.Windows.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Semaphore.Windows.cs
@@ -22,20 +22,36 @@ private Semaphore(SafeWaitHandle handle)
             SafeWaitHandle = handle;
         }
 
+        private void CreateSemaphoreCore(int initialCount, int maximumCount)
+        {
+            ValidateArguments(initialCount, maximumCount);
+
+            SafeWaitHandle handle =
+                Interop.Kernel32.CreateSemaphoreEx(
+                    lpSecurityAttributes: 0,
+                    initialCount,
+                    maximumCount,
+                    name: null,
+                    flags: 0,
+                    AccessRights);
+            if (handle.IsInvalid)
+            {
+                int errorCode = Marshal.GetLastPInvokeError();
+                handle.SetHandleAsInvalid();
+                throw Win32Marshal.GetExceptionForWin32Error(errorCode);
+            }
+
+            SafeWaitHandle = handle;
+        }
+
         private unsafe void CreateSemaphoreCore(
             int initialCount,
             int maximumCount,
             string? name,
             NamedWaitHandleOptionsInternal options,
             out bool createdNew)
         {
-            ArgumentOutOfRangeException.ThrowIfNegative(initialCount);
-            ArgumentOutOfRangeException.ThrowIfNegativeOrZero(maximumCount);
-
-            if (initialCount > maximumCount)
-            {
-                throw new ArgumentException(SR.Argument_SemaphoreInitialMaximum);
-            }
+            ValidateArguments(initialCount, maximumCount);
 
 #if !TARGET_WINDOWS
             if (name != null)
@@ -77,11 +93,13 @@ private unsafe void CreateSemaphoreCore(
 
                 if (myHandle.IsInvalid)
                 {
-                    myHandle.Dispose();
+                    myHandle.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);
                 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Semaphore.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Semaphore.cs
@@ -14,7 +14,7 @@ public sealed partial class Semaphore : WaitHandle
         // Win32 only takes maximum count of int.MaxValue
         public Semaphore(int initialCount, int maximumCount)
         {
-            CreateSemaphoreCore(initialCount, maximumCount, name: null, options: default, out _);
+            CreateSemaphoreCore(initialCount, maximumCount);
         }
 
         /// <summary>
@@ -74,6 +74,17 @@ public Semaphore(int initialCount, int maximumCount, string? name, out bool crea
             CreateSemaphoreCore(initialCount, maximumCount, name, options: default, out createdNew);
         }
 
+        private static void ValidateArguments(int initialCount, int maximumCount)
+        {
+            ArgumentOutOfRangeException.ThrowIfNegative(initialCount);
+            ArgumentOutOfRangeException.ThrowIfNegativeOrZero(maximumCount);
+
+            if (initialCount > maximumCount)
+            {
+                throw new ArgumentException(SR.Argument_SemaphoreInitialMaximum);
+            }
+        }
+
         /// <summary>
         /// Opens an existing named semaphore.
         /// </summary>

Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,12 @@ namespace System.Threading`
`10`	`10`	`{`
`11`	`11`	`public partial class EventWaitHandle`
`12`	`12`	`{`
	`13`	`+ private void CreateEventCore(bool initialState, EventResetMode mode)`
	`14`	`+ {`
	`15`	`+ ValidateMode(mode);`
	`16`	`+ SafeWaitHandle = WaitSubsystem.NewEvent(initialState, mode);`
	`17`	`+ }`
	`18`	`+`
`13`	`19`	`#pragma warning disable IDE0060 // Unused parameter`
`14`	`20`	`private void CreateEventCore(`
`15`	`21`	`bool initialState,`
`@@ -18,10 +24,7 @@ private void CreateEventCore(`
`18`	`24`	`NamedWaitHandleOptionsInternal options,`
`19`	`25`	`out bool createdNew)`
`20`	`26`	`{`
`21`		`- if (mode != EventResetMode.AutoReset && mode != EventResetMode.ManualReset)`
`22`		`- {`
`23`		`- throw new ArgumentException(SR.Argument_InvalidFlag, nameof(mode));`
`24`		`- }`
	`27`	`+ ValidateMode(mode);`
`25`	`28`
`26`	`29`	`if (name != null)`
`27`	`30`	`{`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ public partial class EventWaitHandle : WaitHandle`
`12`	`12`	`{`
`13`	`13`	`public EventWaitHandle(bool initialState, EventResetMode mode)`
`14`	`14`	`{`
`15`		`- CreateEventCore(initialState, mode, name: null, options: default, out _);`
	`15`	`+ CreateEventCore(initialState, mode);`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`/// <summary>`
`@@ -64,6 +64,14 @@ public EventWaitHandle(bool initialState, EventResetMode mode, string? name, out`
`64`	`64`	`CreateEventCore(initialState, mode, name, options: default, out createdNew);`
`65`	`65`	`}`
`66`	`66`
	`67`	`+ private static void ValidateMode(EventResetMode mode)`
	`68`	`+ {`
	`69`	`+ if (mode != EventResetMode.AutoReset && mode != EventResetMode.ManualReset)`
	`70`	`+ {`
	`71`	`+ throw new ArgumentException(SR.Argument_InvalidFlag, nameof(mode));`
	`72`	`+ }`
	`73`	`+ }`
	`74`	`+`
`67`	`75`	`/// <summary>`
`68`	`76`	`/// Opens an existing named event.`
`69`	`77`	`/// </summary>`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,8 @@ namespace System.Threading`
`10`	`10`	`{`
`11`	`11`	`public sealed partial class Mutex`
`12`	`12`	`{`
	`13`	`+ private void CreateMutexCore(bool initiallyOwned) => SafeWaitHandle = WaitSubsystem.NewMutex(initiallyOwned);`
	`14`	`+`
`13`	`15`	`private void CreateMutexCore(`
`14`	`16`	`bool initiallyOwned,`
`15`	`17`	`string? name,`
Original file line number	Diff line number	Diff line change
`@@ -82,12 +82,12 @@ public Mutex(string? name, NamedWaitHandleOptions options)`
`82`	`82`
`83`	`83`	`public Mutex(bool initiallyOwned)`
`84`	`84`	`{`
`85`		`- CreateMutexCore(initiallyOwned, name: null, options: default, createdNew: out _);`
	`85`	`+ CreateMutexCore(initiallyOwned);`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`public Mutex()`
`89`	`89`	`{`
`90`		`- CreateMutexCore(initiallyOwned: false, name: null, options: default, createdNew: out _);`
	`90`	`+ CreateMutexCore(initiallyOwned: false);`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`private Mutex(SafeWaitHandle handle)`