Adjusted Kernel32, User32, and Net assemblies to work with generator

Author: dahall

Net/DhcpClient.cs

@@ -16,7 +16,7 @@ public class DhcpClient : IDisposable
 	private static readonly DhcpInit init = new();
 #pragma warning restore IDE0052 // Remove unread private members
 
-	private readonly SafeEventHandle closing = CreateEvent(default, false, false), updateList = CreateEvent(default, false, false);
+	private SafeEventHandle closing = CreateEvent(), updateList = CreateEvent();
 	private readonly SafeHTHREAD hThread;
 	private readonly Dictionary<HEVENT, DHCP_OPTION_ID> paramChgEvents = new();
 

PInvoke/Kernel32/FileApi.cs

@@ -11044,7 +11044,7 @@ public partial class SafeFindChangeNotificationHandle { }
 
 	/// <summary>Provides a <see cref="SafeHandle"/> that releases a created HFILE instance at disposal using CloseHandle.</summary>
 	[AutoSafeHandle(null, typeof(HFILE), typeof(SafeSyncHandle))]
-	[AdjustAutoMethodNamePattern(@"File|ExW\b|Ex\b|W?\b", "")]
+	[AdjustAutoMethodNamePattern(@"File(?!Type)|ExW\b|Ex\b|W?\b", "")]
 	public partial class SafeHFILE
 	{
 		/// <summary>Performs an implicit conversion from <see cref="Microsoft.Win32.SafeHandles.SafeFileHandle"/> to <see cref="SafeHFILE"/>.</summary>

PInvoke/Kernel32/LibLoaderApi.cs

@@ -7866,6 +7866,88 @@ public partial class SafeHPROCESS
 	[AdjustAutoMethodNamePattern(@"Thread|Ex\b", "")]
 	public partial class SafeHTHREAD
 	{
+		/// <summary>
+		/// <para>Creates a thread to execute within the virtual address space of the calling process.</para>
+		/// <para>To create a thread that runs in the virtual address space of another process, use the <c>CreateRemoteThread</c> function.</para>
+		/// </summary>
+		/// <param name="lpStartAddress">
+		/// A pointer to the application-defined function to be executed by the thread. This pointer represents the starting address of the
+		/// thread. For more information on the thread function, see <c>ThreadProc</c>.
+		/// </param>
+		/// <param name="lpParameter">A pointer to a variable to be passed to the thread.</param>
+		/// <param name="lpThreadId">
+		/// A pointer to a variable that receives the thread identifier. If this parameter is <c>NULL</c>, the thread identifier is not returned.
+		/// </param>
+		/// <param name="dwCreationFlags">
+		/// <para>The flags that control the creation of the thread.</para>
+		/// <list type="table">
+		/// <listheader>
+		/// <term>Value</term>
+		/// <term>Meaning</term>
+		/// </listheader>
+		/// <item>
+		/// <term>0</term>
+		/// <term>The thread runs immediately after creation.</term>
+		/// </item>
+		/// <item>
+		/// <term>CREATE_SUSPENDED 0x00000004</term>
+		/// <term>The thread is created in a suspended state, and does not run until the ResumeThread function is called.</term>
+		/// </item>
+		/// <item>
+		/// <term>STACK_SIZE_PARAM_IS_A_RESERVATION 0x00010000</term>
+		/// <term>
+		/// The dwStackSize parameter specifies the initial reserve size of the stack. If this flag is not specified, dwStackSize specifies
+		/// the commit size.
+		/// </term>
+		/// </item>
+		/// </list>
+		/// </param>
+		/// <param name="dwStackSize">
+		/// The initial size of the stack, in bytes. The system rounds this value to the nearest page. If this parameter is zero, the new
+		/// thread uses the default size for the executable. For more information, see Thread Stack Size.
+		/// </param>
+		/// <param name="lpThreadAttributes">
+		/// <para>
+		/// A pointer to a <c>SECURITY_ATTRIBUTES</c> structure that determines whether the returned handle can be inherited by child
+		/// processes. If lpThreadAttributes is NULL, the handle cannot be inherited.
+		/// </para>
+		/// <para>
+		/// The <c>lpSecurityDescriptor</c> member of the structure specifies a security descriptor for the new thread. If lpThreadAttributes
+		/// is NULL, the thread gets a default security descriptor. The ACLs in the default security descriptor for a thread come from the
+		/// primary token of the creator.
+		/// </para>
+		/// </param>
+		/// <returns>
+		/// <para>If the function succeeds, the return value is a handle to the new thread.</para>
+		/// <para>If the function fails, the return value is <c>NULL</c>. To get extended error information, call <c>GetLastError</c>.</para>
+		/// <para>
+		/// Note that <c>CreateThread</c> may succeed even if lpStartAddress points to data, code, or is not accessible. If the start address
+		/// is invalid when the thread runs, an exception occurs, and the thread terminates. Thread termination due to a invalid start
+		/// address is handled as an error exit for the thread's process. This behavior is similar to the asynchronous nature of
+		/// <c>CreateProcess</c>, where the process is created even if it refers to invalid or missing dynamic-link libraries (DLLs).
+		/// </para>
+		/// </returns>
+		public static SafeHTHREAD Create(ThreadProc lpStartAddress, [In, Optional] IntPtr lpParameter, out uint lpThreadId, [Optional] CREATE_THREAD_FLAGS dwCreationFlags, [Optional] SizeT dwStackSize, [In, Optional] SECURITY_ATTRIBUTES? lpThreadAttributes) =>
+			Kernel32.CreateThread(lpThreadAttributes, dwStackSize, lpStartAddress, lpParameter, dwCreationFlags, out lpThreadId);
+
+		/// <summary>
+		/// <para>Creates a thread to execute within the virtual address space of the calling process.</para>
+		/// <para>To create a thread that runs in the virtual address space of another process, use the <c>CreateRemoteThread</c> function.</para>
+		/// </summary>
+		/// <param name="lpStartAddress">A pointer to the application-defined function to be executed by the thread. This pointer represents the starting address of the
+		/// thread. For more information on the thread function, see <c>ThreadProc</c>.</param>
+		/// <returns>
+		/// <para>If the function succeeds, the return value is a handle to the new thread.</para>
+		/// <para>If the function fails, the return value is <c>NULL</c>. To get extended error information, call <c>GetLastError</c>.</para>
+		/// <para>
+		/// Note that <c>CreateThread</c> may succeed even if lpStartAddress points to data, code, or is not accessible. If the start address
+		/// is invalid when the thread runs, an exception occurs, and the thread terminates. Thread termination due to a invalid start
+		/// address is handled as an error exit for the thread's process. This behavior is similar to the asynchronous nature of
+		/// <c>CreateProcess</c>, where the process is created even if it refers to invalid or missing dynamic-link libraries (DLLs).
+		/// </para>
+		/// </returns>
+		public static SafeHTHREAD Create(ThreadProc lpStartAddress) => Create(lpStartAddress, IntPtr.Zero, out _);
+
 		/// <summary>Gets a handle to the current thread that can be used across processes.</summary>
 		/// <value>The current thread handle.</value>
 		public static SafeHTHREAD Current => new(GetCurrentThread().Duplicate());

PInvoke/Kernel32/ProcessThreadsApi.cs

@@ -355,7 +355,6 @@ public enum WAIT_STATUS : uint
 	// LPCTSTR lpName); https://msdn.microsoft.com/en-us/library/windows/desktop/ms682396(v=vs.85).aspx
 	[DllImport(Lib.Kernel32, SetLastError = true, CharSet = CharSet.Auto)]
 	[PInvokeData("WinBase.h", MSDNShortId = "ms682396")]
-	[return: AddAsCtor]
 	public static extern SafeEventHandle CreateEvent([In, Optional] SECURITY_ATTRIBUTES? lpEventAttributes, [Optional, MarshalAs(UnmanagedType.Bool)] bool bManualReset,
 		[Optional, MarshalAs(UnmanagedType.Bool)] bool bInitialState, [In, Optional] string? lpName);
 
@@ -1245,7 +1244,6 @@ public static extern bool InitOnceBeginInitialize(ref INIT_ONCE lpInitOnce, INIT
 	// HANDLE WINAPI OpenEvent( _In_ DWORD dwDesiredAccess, _In_ BOOL bInheritHandle, _In_ LPCTSTR lpName); https://msdn.microsoft.com/en-us/library/windows/desktop/ms684305(v=vs.85).aspx
 	[DllImport(Lib.Kernel32, SetLastError = true, CharSet = CharSet.Auto)]
 	[PInvokeData("WinBase.h", MSDNShortId = "ms684305")]
-	[return: AddAsCtor]
 	public static extern SafeEventHandle OpenEvent(ACCESS_MASK dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, string lpName);
 
 	/// <summary>Opens an existing named mutex object.</summary>

PInvoke/Kernel32/SynchApi.cs

@@ -26,7 +26,4 @@ Structures
   <ItemGroup>
     <ProjectReference Include="..\Shared\Vanara.PInvoke.Shared.csproj" />
   </ItemGroup>
-  <ItemGroup>
-    <Folder Include="Properties\" />
-  </ItemGroup>
 </Project>

PInvoke/Kernel32/Vanara.PInvoke.Kernel32.csproj

@@ -647,7 +647,7 @@ public static extern HRESULT GetApplicationRestartSettings([In] HPROCESS hProces
 	[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
 	[PInvokeData("Winbase.h", MSDNShortId = "aa375700")]
 	[return: MarshalAs(UnmanagedType.Bool)]
-	public static extern bool QueryActCtxSettingsW([Optional, Ignore] uint dwFlags, [In, AddAsMember] HACTCTX hActCtx, [Optional, Ignore] string? settingsNameSpace,
+	public static extern bool QueryActCtxSettingsW([Optional, Ignore] uint dwFlags, [In, AddAsMember] HACTCTX hActCtx, [Optional] string? settingsNameSpace,
 		string settingName, [Out, SizeDef(nameof(dwBuffer), SizingMethod.Query, OutVarName = nameof(pdwWrittenOrRequired))] StringBuilder? pvBuffer, SizeT dwBuffer, out SizeT pdwWrittenOrRequired);
 
 	/// <summary>The <c>QueryActCtxW</c> function queries the activation context.</summary>

PInvoke/Kernel32/WinBase.App.cs

@@ -195,7 +195,7 @@ public enum IMAGE_FILE_MACHINE : ushort
 	/// <see langword="true"/> if the process is running under WOW64. If the process is running under 32-bit Windows, the value is set
 	/// to <see langword="false"/>. If the process is a 64-bit application running under 64-bit Windows, the value is also set to <see langword="false"/>.
 	/// </returns>
-	public static bool IsWow64(this HPROCESS hProc) => Environment.OSVersion.Version >= new Version(5, 1) && IsWow64Process(hProc, out var b) && b;
+	public static bool IsWow64([In] this HPROCESS hProc) => Environment.OSVersion.Version >= new Version(5, 1) && IsWow64Process(hProc, out var b) && b;
 
 	/// <summary>
 	/// Determines whether the specified process is running under WOW64; also returns additional machine process and architecture information.

PInvoke/Kernel32/Wow64ApiSet.cs

@@ -26,7 +26,7 @@ public ModalDialog(HINSTANCE hInst, ResourceId dlgId) : this(new SafeHINSTANCE(h
 	/// dialog box template or an integer value that specifies the resource identifier of the dialog box template.
 	/// </param>
 	public ModalDialog(string libraryPath, ResourceId dlgId)
-		: this(Win32Error.ThrowLastErrorIfInvalid(LoadLibraryEx(libraryPath, LoadLibraryExFlags.LOAD_LIBRARY_AS_DATAFILE)), dlgId) { }
+		: this(Win32Error.ThrowLastErrorIfInvalid(LoadLibraryEx(libraryPath, default, LoadLibraryExFlags.LOAD_LIBRARY_AS_DATAFILE)), dlgId) { }
 
 	/// <inheritdoc/>
 	public HWND Handle { get; protected set; }

PInvoke/User32/ModalDialog.cs

@@ -239,7 +239,7 @@ public void CriticalSectionTest()
 		SetCriticalSectionSpinCount(ref critSect, 400);
 		try
 		{
-			using SafeHTHREAD hThread = CreateThread(null, 0, ThreadProc, default, 0, out _);
+			using var hThread = SafeHTHREAD.Create(ThreadProc);
 			WaitForSingleObject(hThread, INFINITE);
 			Assert.That(GetExitCodeThread(hThread, out uint c), ResultIs.Successful);
 			Assert.That(c, Is.Zero);
@@ -355,7 +355,7 @@ public void EventTest()
 			TestContext.Write("MyMain thread writing to the shared buffer...\n");
 
 			// Set ghWriteEvent to signaled
-			Assert.That(SetEvent(ghWriteEvent), ResultIs.Successful);
+			Assert.That(ghWriteEvent.Set(), ResultIs.Successful);
 
 			TestContext.Write("MyMain thread waiting for threads to exit...\n");
 
@@ -377,8 +377,8 @@ public void EventTest()
 			foreach (SafeHTHREAD t in ghThreads)
 				t.Dispose();
 
-			Assert.That(ResetEvent(ghWriteEvent), ResultIs.Successful);
-			Assert.That(PulseEvent(ghWriteEvent), ResultIs.Successful);
+			Assert.That(ghWriteEvent.Reset(), ResultIs.Successful);
+			Assert.That(ghWriteEvent.Pulse(), ResultIs.Successful);
 		}
 
 		uint ThreadProc(IntPtr _)