Fix compilation error and modernize (#10334)

gewarren · web-flow · commit 1975883a82ff · 2024-08-29T07:36:16.000-07:00
diff --git a/snippets/csharp/Microsoft.Win32.SafeHandles/SafeWaitHandle/Overview/Project.csproj b/snippets/csharp/Microsoft.Win32.SafeHandles/SafeWaitHandle/Overview/Project.csproj
@@ -1,8 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <OutputType>Library</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
    
 </Project>
diff --git a/snippets/csharp/Microsoft.Win32.SafeHandles/SafeWaitHandle/Overview/sample.cs b/snippets/csharp/Microsoft.Win32.SafeHandles/SafeWaitHandle/Overview/sample.cs
@@ -7,7 +7,7 @@ class SafeHandlesExample
 {
     static void Main()
     {
-        UnmanagedMutex uMutex = new UnmanagedMutex("YourCompanyName_SafeHandlesExample_MUTEX");
+        UnmanagedMutex uMutex = new("YourCompanyName_SafeHandlesExample_MUTEX");
 
         try
         {
@@ -22,49 +22,43 @@ static void Main()
         finally
         {
             uMutex.Release();
-            Console.WriteLine("Mutex Released.");
+            Console.WriteLine("Mutex released.");
         }
-
-        Console.ReadLine();
     }
 }
 
-class UnmanagedMutex
+partial class UnmanagedMutex(string Name)
 {
-
     // Use interop to call the CreateMutex function.
-    // For more information about CreateMutex,
-    // see the unmanaged MSDN reference library.
-    [DllImport("kernel32.dll", CharSet=CharSet.Unicode)]
-    static extern SafeWaitHandle CreateMutex(IntPtr lpMutexAttributes, bool bInitialOwner,
-    string lpName);
+    [LibraryImport("kernel32.dll", EntryPoint = "CreateMutexW", StringMarshalling = StringMarshalling.Utf16)]
+    private static partial SafeWaitHandle CreateMutex(
+        IntPtr lpMutexAttributes,
+        [MarshalAs(UnmanagedType.Bool)] bool bInitialOwner,
+        string lpName
+        );
 
     // Use interop to call the ReleaseMutex function.
     // For more information about ReleaseMutex,
     // see the unmanaged MSDN reference library.
-    [DllImport("kernel32.dll")]
-    public static extern bool ReleaseMutex(SafeWaitHandle hMutex);
+    [LibraryImport("kernel32.dll")]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    public static partial bool ReleaseMutex(SafeWaitHandle hMutex);
 
-    private SafeWaitHandle handleValue = null;
-    private IntPtr mutexAttrValue = IntPtr.Zero;
-    private string nameValue = null;
-
-    public UnmanagedMutex(string Name)
-    {
-        nameValue = Name;
-    }
+    private SafeWaitHandle _handleValue = null;
+    private readonly IntPtr _mutexAttrValue = IntPtr.Zero;
+    private string nameValue = Name;
 
     public void Create()
     {
         ArgumentException.ThrowIfNullOrEmpty(nameValue);
 
-        handleValue = CreateMutex(mutexAttrValue,
+        _handleValue = CreateMutex(_mutexAttrValue,
                                         true, nameValue);
 
         // If the handle is invalid,
         // get the last Win32 error
         // and throw a Win32Exception.
-        if (handleValue.IsInvalid)
+        if (_handleValue.IsInvalid)
         {
             Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());
         }
@@ -74,11 +68,9 @@ public SafeWaitHandle Handle
     {
         get
         {
-            // If the handle is valid,
-            // return it.
-            if (!handleValue.IsInvalid)
+            if (!_handleValue.IsInvalid)
             {
-                return handleValue;
+                return _handleValue;
             }
             else
             {
@@ -87,17 +79,11 @@ public SafeWaitHandle Handle
         }
     }
 
-    public string Name
-    {
-        get
-        {
-            return nameValue;
-        }
-    }
+    public string Name => nameValue;
 
     public void Release()
     {
-        ReleaseMutex(handleValue);
+        ReleaseMutex(_handleValue);
     }
 }
 //</Snippet1>
diff --git a/xml/Microsoft.Win32.SafeHandles/SafeWaitHandle.xml b/xml/Microsoft.Win32.SafeHandles/SafeWaitHandle.xml
@@ -65,22 +65,22 @@
   <Docs>
     <summary>Represents a wrapper class for a wait handle.</summary>
     <remarks>
-      <format type="text/markdown"><![CDATA[  
-  
-## Remarks  
- The <xref:Microsoft.Win32.SafeHandles.SafeWaitHandle> class is used by the <xref:System.Threading.WaitHandle?displayProperty=nameWithType> class. It is a wrapper for Win32 mutexes and auto and manual reset events.  
-  
+      <format type="text/markdown"><![CDATA[
+
+## Remarks
+
+The <xref:Microsoft.Win32.SafeHandles.SafeWaitHandle> class is used by the <xref:System.Threading.WaitHandle?displayProperty=nameWithType> class. It is a wrapper for Win32 mutexes and auto and manual reset events.
+
 > [!IMPORTANT]
->  This type implements the <xref:System.IDisposable> interface. When you have finished using the type, you should dispose of it either directly or indirectly. To dispose of the type directly, call its <xref:System.IDisposable.Dispose%2A> method in a `try`/`catch` block. To dispose of it indirectly, use a language construct such as `using` (in C#) or `Using` (in Visual Basic). For more information, see the "Using an Object that Implements IDisposable" section in the <xref:System.IDisposable> interface topic.  
-  
-   
-  
-## Examples  
- The following code example demonstrates how to use interop to create a mutex using the <xref:Microsoft.Win32.SafeHandles.SafeWaitHandle> class and the unmanaged `CreateMutex` function.  
-  
+> This type implements the <xref:System.IDisposable> interface. When you have finished using the type, you should dispose of it either directly or indirectly. To dispose of the type directly, call its <xref:System.IDisposable.Dispose%2A> method in a `try`/`catch` block. To dispose of it indirectly, use a language construct such as `using` (in C#) or `Using` (in Visual Basic).
+
+## Examples
+
+The following code example demonstrates how to use interop to create a mutex using the <xref:Microsoft.Win32.SafeHandles.SafeWaitHandle> class and the unmanaged `CreateMutex` function.
+
  :::code language="csharp" source="~/snippets/csharp/Microsoft.Win32.SafeHandles/SafeWaitHandle/Overview/sample.cs" id="Snippet1":::
- :::code language="vb" source="~/snippets/visualbasic/VS_Snippets_CLR/Microsoft.Win32.SafeHandles.SafeWaitHandle/vb/sample.vb" id="Snippet1":::  
-  
+ :::code language="vb" source="~/snippets/visualbasic/VS_Snippets_CLR/Microsoft.Win32.SafeHandles.SafeWaitHandle/vb/sample.vb" id="Snippet1":::
+
  ]]></format>
     </remarks>
     <altmember cref="T:Microsoft.Win32.SafeHandles.SafeHandleZeroOrMinusOneIsInvalid" />
@@ -169,14 +169,14 @@
           <see langword="true" /> to reliably release the handle during the finalization phase; <see langword="false" /> to prevent reliable release (not recommended).</param>
         <summary>Initializes a new instance of the <see cref="T:Microsoft.Win32.SafeHandles.SafeWaitHandle" /> class.</summary>
         <remarks>
-          <format type="text/markdown"><![CDATA[  
-  
-## Examples  
- The following code example demonstrates how to use interop to create a mutex using the <xref:Microsoft.Win32.SafeHandles.SafeWaitHandle> class and the unmanaged `CreateMutex` function.  
-  
+          <format type="text/markdown"><![CDATA[
+
+## Examples
+ The following code example demonstrates how to use interop to create a mutex using the <xref:Microsoft.Win32.SafeHandles.SafeWaitHandle> class and the unmanaged `CreateMutex` function.
+
  :::code language="csharp" source="~/snippets/csharp/Microsoft.Win32.SafeHandles/SafeWaitHandle/.ctor/sample.cs" id="Snippet1":::
- :::code language="vb" source="~/snippets/visualbasic/VS_Snippets_CLR/Microsoft.Win32.SafeHandles.SafeWaitHandle-ctor/vb/sample.vb" id="Snippet1":::  
-  
+ :::code language="vb" source="~/snippets/visualbasic/VS_Snippets_CLR/Microsoft.Win32.SafeHandles.SafeWaitHandle-ctor/vb/sample.vb" id="Snippet1":::
+
  ]]></format>
         </remarks>
         <altmember cref="T:Microsoft.Win32.SafeHandles.SafeHandleZeroOrMinusOneIsInvalid" />

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ class SafeHandlesExample`
`7`	`7`	`{`
`8`	`8`	`static void Main()`
`9`	`9`	`{`
`10`		`- UnmanagedMutex uMutex = new UnmanagedMutex("YourCompanyName_SafeHandlesExample_MUTEX");`
	`10`	`+ UnmanagedMutex uMutex = new("YourCompanyName_SafeHandlesExample_MUTEX");`
`11`	`11`
`12`	`12`	`try`
`13`	`13`	`{`
`@@ -22,49 +22,43 @@ static void Main()`
`22`	`22`	`finally`
`23`	`23`	`{`
`24`	`24`	`uMutex.Release();`
`25`		`- Console.WriteLine("Mutex Released.");`
	`25`	`+ Console.WriteLine("Mutex released.");`
`26`	`26`	`}`
`27`		`-`
`28`		`- Console.ReadLine();`
`29`	`27`	`}`
`30`	`28`	`}`
`31`	`29`
`32`		`-class UnmanagedMutex`
	`30`	`+partial class UnmanagedMutex(string Name)`
`33`	`31`	`{`
`34`		`-`
`35`	`32`	`// Use interop to call the CreateMutex function.`
`36`		`- // For more information about CreateMutex,`
`37`		`- // see the unmanaged MSDN reference library.`
`38`		`- [DllImport("kernel32.dll", CharSet=CharSet.Unicode)]`
`39`		`- static extern SafeWaitHandle CreateMutex(IntPtr lpMutexAttributes, bool bInitialOwner,`
`40`		`- string lpName);`
	`33`	`+ [LibraryImport("kernel32.dll", EntryPoint = "CreateMutexW", StringMarshalling = StringMarshalling.Utf16)]`
	`34`	`+ private static partial SafeWaitHandle CreateMutex(`
	`35`	`+ IntPtr lpMutexAttributes,`
	`36`	`+ [MarshalAs(UnmanagedType.Bool)] bool bInitialOwner,`
	`37`	`+ string lpName`
	`38`	`+ );`
`41`	`39`
`42`	`40`	`// Use interop to call the ReleaseMutex function.`
`43`	`41`	`// For more information about ReleaseMutex,`
`44`	`42`	`// see the unmanaged MSDN reference library.`
`45`		`- [DllImport("kernel32.dll")]`
`46`		`- public static extern bool ReleaseMutex(SafeWaitHandle hMutex);`
	`43`	`+ [LibraryImport("kernel32.dll")]`
	`44`	`+ [return: MarshalAs(UnmanagedType.Bool)]`
	`45`	`+ public static partial bool ReleaseMutex(SafeWaitHandle hMutex);`
`47`	`46`
`48`		`- private SafeWaitHandle handleValue = null;`
`49`		`- private IntPtr mutexAttrValue = IntPtr.Zero;`
`50`		`- private string nameValue = null;`
`51`		`-`
`52`		`- public UnmanagedMutex(string Name)`
`53`		`- {`
`54`		`- nameValue = Name;`
`55`		`- }`
	`47`	`+ private SafeWaitHandle _handleValue = null;`
	`48`	`+ private readonly IntPtr _mutexAttrValue = IntPtr.Zero;`
	`49`	`+ private string nameValue = Name;`
`56`	`50`
`57`	`51`	`public void Create()`
`58`	`52`	`{`
`59`	`53`	`ArgumentException.ThrowIfNullOrEmpty(nameValue);`
`60`	`54`
`61`		`- handleValue = CreateMutex(mutexAttrValue,`
	`55`	`+ _handleValue = CreateMutex(_mutexAttrValue,`
`62`	`56`	`true, nameValue);`
`63`	`57`
`64`	`58`	`// If the handle is invalid,`
`65`	`59`	`// get the last Win32 error`
`66`	`60`	`// and throw a Win32Exception.`
`67`		`- if (handleValue.IsInvalid)`
	`61`	`+ if (_handleValue.IsInvalid)`
`68`	`62`	`{`
`69`	`63`	`Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());`
`70`	`64`	`}`
`@@ -74,11 +68,9 @@ public SafeWaitHandle Handle`
`74`	`68`	`{`
`75`	`69`	`get`
`76`	`70`	`{`
`77`		`- // If the handle is valid,`
`78`		`- // return it.`
`79`		`- if (!handleValue.IsInvalid)`
	`71`	`+ if (!_handleValue.IsInvalid)`
`80`	`72`	`{`
`81`		`- return handleValue;`
	`73`	`+ return _handleValue;`
`82`	`74`	`}`
`83`	`75`	`else`
`84`	`76`	`{`
`@@ -87,17 +79,11 @@ public SafeWaitHandle Handle`
`87`	`79`	`}`
`88`	`80`	`}`
`89`	`81`
`90`		`- public string Name`
`91`		`- {`
`92`		`- get`
`93`		`- {`
`94`		`- return nameValue;`
`95`		`- }`
`96`		`- }`
	`82`	`+ public string Name => nameValue;`
`97`	`83`
`98`	`84`	`public void Release()`
`99`	`85`	`{`
`100`		`- ReleaseMutex(handleValue);`
	`86`	`+ ReleaseMutex(_handleValue);`
`101`	`87`	`}`
`102`	`88`	`}`
`103`	`89`	`//</Snippet1>`