Completed autogen handle work

Author: dahall

CodeGen/HandleModel.cs

@@ -30,6 +30,7 @@ public string GetSafeHandleCode(string summaryText = "")
 		templateText = ReplaceMarker(templateText, "#2#", HandleName);
 		templateText = ReplaceMarker(templateText, "#3#", InheritedHandleName);
 		templateText = ReplaceMarker(templateText, "#4#", CloseCode);
+		templateText = ReplaceMarker(templateText, "#5#", string.IsNullOrEmpty(HandleName) ? "IntPtr" : "");
 		var closeCode = string.IsNullOrEmpty(CloseCode) ? "" : (CloseCode!.Trim().StartsWith("{") ? CloseCode : $"=> {CloseCode};");
 		var baseClassName = BaseClassName + (InterfaceName is "IHandle" or "Vanara.PInvoke.IHandle" or "" ? "" : $", {InterfaceName}");
 		return Util.ReplaceWholeWords(templateText, new Dictionary<string, string>()

CodeGen/SafeHandleTemplate.cs

@@ -3,7 +3,6 @@
 #1#public static partial class ParentClassName
 {
 #1#	SummaryText
-	/// <seealso cref="BaseClassName"/>
 	public partial class ClassName : BaseClassName
 	{
 		/// <summary>Initializes a new instance of the <see cref="ClassName"/> class and assigns an existing handle.</summary>
@@ -16,7 +15,12 @@ public ClassName(IntPtr preexistingHandle = default, bool ownsHandle = true) : b
 		public static new ClassName Null => new(IntPtr.Zero, false);
 #pragma warning restore CS0109 // Member does not hide an inherited member
 
-#2#		/// <summary>Initializes a new instance of the <see cref="ClassName"/> class and assigns an existing handle.</summary>
+#5#       /// <summary>Performs an implicit conversion from <see cref="ClassName"/> to <see cref="IntPtr"/>.</summary>
+		/// <param name="h">The safe handle instance.</param>
+		/// <returns>The result of the conversion.</returns>
+		public static implicit operator IntPtr(ClassName h) => h.handle;
+
+#5##2#		/// <summary>Initializes a new instance of the <see cref="ClassName"/> class and assigns an existing handle.</summary>
 		/// <param name="preexistingHandle">An <see cref="HandleName"/> object that represents the pre-existing handle to use.</param>
 		/// <param name="ownsHandle"><see langword="true"/> to reliably release the handle during the finalization phase; otherwise, <see langword="false"/> (not recommended).</param>
 		public ClassName(HandleName preexistingHandle = default, bool ownsHandle = true) : base((IntPtr)preexistingHandle, ownsHandle) { }

Net/DnsService.cs

@@ -175,7 +175,7 @@ public async Task RegisterAsync(bool unicastEnabled = false, NetworkInterface? a
 		{
 			Version = DNS_QUERY_REQUEST_VERSION1,
 			InterfaceIndex = (uint)(adapter?.GetIPProperties().GetIPv4Properties().Index ?? 0),
-			pServiceInstance = pSvcInst,
+			pServiceInstance = (IntPtr)pSvcInst,
 			pQueryContext = ctx,
 			pRegisterCompletionCallback = RegCallback,
 			unicastEnabled = unicastEnabled

PInvoke/ActiveDS/IADs.Interface4.cs

@@ -2785,8 +2785,21 @@ public partial struct ADS_SEARCH_HANDLE { }
 	/// <summary>
 	/// Provides a <see cref="SafeHandle"/> for <see cref="ADS_SEARCH_HANDLE"/> that is disposed using <see cref="IDirectorySearch.CloseSearchHandle"/>.
 	/// </summary>
-	[AutoSafeHandle("{ try { ids?.CloseSearchHandle(handle); return true; } catch { return false; } }", typeof(ADS_SEARCH_HANDLE))]
-	public partial class SafeADS_SEARCH_HANDLE { }
+	public class SafeADS_SEARCH_HANDLE : SafeHANDLE
+	{
+		private readonly IDirectorySearch? ids;
+
+		/// <summary>Initializes a new instance of the <see cref="SafeADS_SEARCH_HANDLE"/> class.</summary>
+		internal SafeADS_SEARCH_HANDLE(IDirectorySearch? ids = null, ADS_SEARCH_HANDLE h = default) : base((IntPtr)h, true) => this.ids = ids;
+
+		/// <summary>Performs an implicit conversion from <see cref="SafeADS_SEARCH_HANDLE"/> to <see cref="ADS_SEARCH_HANDLE"/>.</summary>
+		/// <param name="h">The safe handle instance.</param>
+		/// <returns>The result of the conversion.</returns>
+		public static implicit operator ADS_SEARCH_HANDLE(SafeADS_SEARCH_HANDLE h) => h.handle;
+
+		/// <inheritdoc/>
+		protected override bool InternalReleaseHandle() { try { ids?.CloseSearchHandle(handle); return true; } catch { return false; } }
+	}
 
 	/*internal class VariantMarshaler<T> : ICustomMarshaler
 	{

PInvoke/DnsApi/WinDns.Funcs.cs

@@ -1712,8 +1712,8 @@ protected override bool InternalReleaseHandle()
 	public partial class SafeDnsRecordList : IEnumerable<DNS_RECORD>
 	{
 		/// <summary>Returns an enumerator that iterates through the collection.</summary>
-		/// <returns>A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection.</returns>
-		/// <exception cref="NotImplementedException"></exception>
+																						/// <returns>A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection.</returns>
+																						/// <exception cref="NotImplementedException"></exception>
 		public IEnumerator<DNS_RECORD> GetEnumerator() => handle.LinkedListToIEnum<DNS_RECORD>(r => r.pNext).GetEnumerator();
 
 		/// <summary>Gets a sequence of pointers to each of the records.</summary>

PInvoke/Lz32/LzExpand.cs

@@ -763,6 +763,50 @@ public enum LZERROR : int
 	public static extern int LZSeek(HLZFILE hFile, int lOffset, SeekOrigin iOrigin);
 
 	/// <summary>Provides a handle to a compressed file.</summary>
-	[AutoHandle]
-	public partial struct HLZFILE { }
+	[StructLayout(LayoutKind.Sequential)]
+	public readonly struct HLZFILE : IHandle
+	{
+		private readonly int handle;
+
+		/// <summary>Initializes a new instance of the <see cref="HLZFILE"/> struct.</summary>
+		/// <param name="preexistingHandle">An <see cref="int"/> object that represents the pre-existing handle to use.</param>
+		public HLZFILE(int preexistingHandle) => handle = preexistingHandle;
+
+		/// <summary>Returns an invalid handle by instantiating a <see cref="HLZFILE"/> object with <c>0</c>.</summary>
+		public static HLZFILE NULL => new(0);
+
+		/// <summary>Gets a value indicating whether this instance is a null handle.</summary>
+		public bool IsNull => handle == 0;
+
+		/// <summary>Performs an explicit conversion from <see cref="HLZFILE"/> to <see cref="int"/>.</summary>
+		/// <param name="h">The handle.</param>
+		/// <returns>The result of the conversion.</returns>
+		public static explicit operator int(HLZFILE h) => h.handle;
+
+		/// <summary>Performs an implicit conversion from <see cref="int"/> to <see cref="HLZFILE"/>.</summary>
+		/// <param name="h">The pointer to a handle.</param>
+		/// <returns>The result of the conversion.</returns>
+		public static implicit operator HLZFILE(int h) => new(h);
+
+		/// <summary>Implements the operator !=.</summary>
+		/// <param name="h1">The first handle.</param>
+		/// <param name="h2">The second handle.</param>
+		/// <returns>The result of the operator.</returns>
+		public static bool operator !=(HLZFILE h1, HLZFILE h2) => !(h1 == h2);
+
+		/// <summary>Implements the operator ==.</summary>
+		/// <param name="h1">The first handle.</param>
+		/// <param name="h2">The second handle.</param>
+		/// <returns>The result of the operator.</returns>
+		public static bool operator ==(HLZFILE h1, HLZFILE h2) => h1.Equals(h2);
+
+		/// <inheritdoc/>
+		public override bool Equals(object? obj) => obj is HLZFILE h && handle == h.handle;
+
+		/// <inheritdoc/>
+		public override int GetHashCode() => handle.GetHashCode();
+
+		/// <inheritdoc/>
+		public IntPtr DangerousGetHandle() => (IntPtr)handle;
+	}
 }

PInvoke/Msi/Msi.cs

@@ -789,14 +789,50 @@ public struct MSIFILEHASHINFO
 	}
 
 	/// <summary>Provides a handle to a MSI instance.</summary>
+	/// <remarks>Initializes a new instance of the <see cref="MSIHANDLE"/> struct.</remarks>
+	/// <param name="preexistingHandle">An <see cref="ulong"/> object that represents the pre-existing handle to use.</param>
 	[PInvokeData("msi.h")]
-	[AutoHandle]
-	public partial struct MSIHANDLE
+	[StructLayout(LayoutKind.Sequential)]
+	public readonly struct MSIHANDLE(ulong preexistingHandle) : IHandle
 	{
+		private readonly ulong handle = preexistingHandle;
+
+		/// <summary>Returns an invalid handle by instantiating a <see cref="MSIHANDLE"/> object with zero.</summary>
+		public static MSIHANDLE NULL => new(0UL);
+
+		/// <summary>Gets a value indicating whether this instance is a null handle.</summary>
+		public bool IsNull => handle == 0UL;
+
 		/// <summary>Performs an explicit conversion from <see cref="MSIHANDLE"/> to <see cref="ulong"/>.</summary>
 		/// <param name="h">The handle.</param>
 		/// <returns>The result of the conversion.</returns>
 		public static explicit operator ulong(MSIHANDLE h) => h.handle;
+
+		/// <summary>Performs an implicit conversion from <see cref="ulong"/> to <see cref="MSIHANDLE"/>.</summary>
+		/// <param name="h">The pointer to a handle.</param>
+		/// <returns>The result of the conversion.</returns>
+		public static implicit operator MSIHANDLE(ulong h) => new(h);
+
+		/// <summary>Implements the operator !=.</summary>
+		/// <param name="h1">The first handle.</param>
+		/// <param name="h2">The second handle.</param>
+		/// <returns>The result of the operator.</returns>
+		public static bool operator !=(MSIHANDLE h1, MSIHANDLE h2) => !(h1 == h2);
+
+		/// <summary>Implements the operator ==.</summary>
+		/// <param name="h1">The first handle.</param>
+		/// <param name="h2">The second handle.</param>
+		/// <returns>The result of the operator.</returns>
+		public static bool operator ==(MSIHANDLE h1, MSIHANDLE h2) => h1.Equals(h2);
+
+		/// <inheritdoc/>
+		public override bool Equals(object? obj) => obj is MSIHANDLE h && handle == h.handle;
+
+		/// <inheritdoc/>
+		public override int GetHashCode() => handle.GetHashCode();
+
+		/// <inheritdoc/>
+		public IntPtr DangerousGetHandle() => new(unchecked((long)handle));
 	}
 
 	/// <summary>

PInvoke/NTDSApi/NTDSAPI.cs

@@ -5174,7 +5174,11 @@ public partial struct SpnArrayHandle
 
 	/// <summary>Provides a <see cref="SafeHandle"/> to an authentication identity that releases its handle at disposal using DsFreePasswordCredentials.</summary>
 	[AutoSafeHandle("{ DsFreePasswordCredentials(handle); return true; }")]
-	public partial class SafeAuthIdentityHandle { }
+	public partial class SafeAuthIdentityHandle
+	{
+		/// <summary>Gets a value that marshals as NULL so that the local thread's identity is used.</summary>
+		public static readonly SafeAuthIdentityHandle LocalThreadIdentity = new();
+	}
 
 	/// <summary>Provides a safe handle to an array of DS_REPSYNCALL_ERRINFO structures returned from <see cref="DsReplicaSyncAll"/>.</summary>
 	/// <seealso cref="Vanara.InteropServices.GenericSafeHandle"/>

PInvoke/Odbc32/Sql.cs

@@ -6042,24 +6042,24 @@ public readonly struct SQLHSTMT(IntPtr preexistingHandle) : ISQLHANDLE
 	/// <summary>
 	/// Provides a <see cref="SafeHandle"/> for <see cref="SQLHDBC"/> that is disposed using <see cref="SQLFreeHandle(SQL_HANDLE, IntPtr)"/>.
 	/// </summary>
-	[AutoSafeHandle("SQLFreeHandle(SQL_HANDLE.SQL_HANDLE_DBC, handle).SQL_SUCCEEDED()")]
+	[AutoSafeHandle("SQLFreeHandle(SQL_HANDLE.SQL_HANDLE_DBC, handle).SQL_SUCCEEDED()", typeof(SQLHDBC))]
 	public partial class SafeSQLHDBC : ISQLHANDLE { }
 
 	/// <summary>
 	/// Provides a <see cref="SafeHandle"/> for <see cref="SQLHDESC"/> that is disposed using <see cref="SQLFreeHandle(SQL_HANDLE, IntPtr)"/>.
 	/// </summary>
-	[AutoSafeHandle("SQLFreeHandle(SQL_HANDLE.SQL_HANDLE_DESC, handle).SQL_SUCCEEDED()")]
+	[AutoSafeHandle("SQLFreeHandle(SQL_HANDLE.SQL_HANDLE_DESC, handle).SQL_SUCCEEDED()", typeof(SQLHDESC))]
 	public partial class SafeSQLHDESC : ISQLHANDLE { }
 
 	/// <summary>
 	/// Provides a <see cref="SafeHandle"/> for <see cref="SQLHENV"/> that is disposed using <see cref="SQLFreeHandle(SQL_HANDLE, IntPtr)"/>.
 	/// </summary>
-	[AutoSafeHandle("SQLFreeHandle(SQL_HANDLE.SQL_HANDLE_ENV, handle).SQL_SUCCEEDED()")]
+	[AutoSafeHandle("SQLFreeHandle(SQL_HANDLE.SQL_HANDLE_ENV, handle).SQL_SUCCEEDED()", typeof(SQLHENV))]
 	public partial class SafeSQLHENV : ISQLHANDLE { }
 
 	/// <summary>
 	/// Provides a <see cref="SafeHandle"/> for <see cref="SQLHSTMT"/> that is disposed using <see cref="SQLFreeHandle(SQL_HANDLE, IntPtr)"/>.
 	/// </summary>
-	[AutoSafeHandle("SQLFreeHandle(SQL_HANDLE.SQL_HANDLE_STMT, handle).SQL_SUCCEEDED()")]
+	[AutoSafeHandle("SQLFreeHandle(SQL_HANDLE.SQL_HANDLE_STMT, handle).SQL_SUCCEEDED()", typeof(SQLHSTMT))]
 	public partial class SafeSQLHSTMT : ISQLHANDLE { }
 }

PInvoke/WinSCard/WinSCard.cs

@@ -4958,4 +4958,12 @@ public struct SCARD_READERSTATE
 		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 36)]
 		public byte[] rgbAtr;
 	}
+
+	public partial struct SCARDHANDLE
+	{
+		/// <summary>Performs an explicit conversion from <see cref="SCARDHANDLE"/> to <see cref="IntPtr"/>.</summary>
+		/// <param name="h">The handle.</param>
+		/// <returns>The result of the conversion.</returns>
+		public static implicit operator UIntPtr(SCARDHANDLE h) => h.handle.ToUIntPtr();
+	}
 }