bottlenoselabs · lithiumtoast · Feb 20, 2025 · Feb 20, 2025 · Feb 20, 2025 · Feb 20, 2025
diff --git a/src/cs/examples/helloworld/helloworld-app/Generated/AssemblyAttributes.g.cs b/src/cs/examples/helloworld/helloworld-app/Generated/AssemblyAttributes.g.cs
@@ -1,5 +1,5 @@
 // <auto-generated>
-//  This code was generated by the following tool on 2025-01-27 02:11:24 GMT-05:00:
+//  This code was generated by the following tool on 2025-02-19 20:34:32 GMT-05:00:
 //      https://github.com/bottlenoselabs/c2cs (v0.0.0.0)
 //
 //  Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.

diff --git a/src/cs/examples/helloworld/helloworld-app/Generated/Runtime.g.cs b/src/cs/examples/helloworld/helloworld-app/Generated/Runtime.g.cs
@@ -1,5 +1,5 @@
 // <auto-generated>
-//  This code was generated by the following tool on 2025-01-27 02:11:24 GMT-05:00:
+//  This code was generated by the following tool on 2025-02-19 20:34:32 GMT-05:00:
 //      https://github.com/bottlenoselabs/c2cs (v0.0.0.0)
 //
 //  Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
@@ -11,6 +11,7 @@
 using System;
 using System.Globalization;
 using System.Runtime.InteropServices;
+using System.Threading;
 
 namespace Interop.Runtime;
 
@@ -578,11 +579,11 @@ public static CString AllocateCString(this INativeAllocator allocator, string st
 ///     An allocator that uses a single block of native memory which can be re-used.
 /// </summary>
 /// <remarks>
-///     <p>
+///     <para>
 ///         The <see cref="ArenaNativeAllocator" /> can be useful in native interoperability situations when you need to
 ///         temporarily allocate memory. For example, when calling native functions sometimes memory needs be available
 ///         for one or more calls but is no longer used after.
-///     </p>
+///     </para>
 /// </remarks>
 public sealed unsafe class ArenaNativeAllocator
     : INativeAllocator, IDisposable
@@ -614,9 +615,10 @@ public ArenaNativeAllocator(int capacity)
 
 #if NET6_0_OR_GREATER
         // malloc
-        _buffer = (IntPtr)NativeMemory.Alloc((UIntPtr)capacity);
+        _buffer = (IntPtr)NativeMemory.AllocZeroed((UIntPtr)capacity);
 #else
         _buffer = Marshal.AllocHGlobal(capacity);
+        new Span<byte>((void*)_buffer, Capacity).Clear();
 #endif
         Capacity = capacity;
     }
@@ -673,14 +675,112 @@ public void Free(IntPtr pointer)
     ///     Resets <see cref="Used" /> to zero and clears the entire underlying block of native memory with zeroes.
     /// </summary>
     /// <remarks>
-    ///     <p>
+    ///     <para>
     ///         Any pointers returned from <see cref="Allocate" /> before calling <see cref="Reset" /> must not be used or else
     ///         there is a risk that the pointers point to unexpected bytes of data.
-    ///     </p>
+    ///     </para>
     /// </remarks>
     public void Reset()
     {
+#if NET6_0_OR_GREATER
+        NativeMemory.Clear((void*)_buffer, (UIntPtr)Used);
+#else
         new Span<byte>((void*)_buffer, Used).Clear();
+#endif
         Used = 0;
     }
 }
+
+/// <summary>
+///     Represents a object instance that has unmanaged resources that can be free-ed, released, or reset.
+/// </summary>
+public abstract class Disposable : IDisposable
+{
+    private volatile int _isDisposed;
+
+    /// <summary>
+    ///     Gets a value indicating whether the object instance has free-ed, released, or reset unmanaged resources.
+    /// </summary>
+    /// <remarks><para><see cref="IsDisposed" /> is thread-safe via atomic operations.</para></remarks>
+    public bool IsDisposed => _isDisposed == 1;
+
+    /// <summary>
+    ///     Performs tasks related to freeing, releasing, or resetting unmanaged resources.
+    /// </summary>
+#pragma warning disable CA1063
+    public void Dispose()
+#pragma warning restore CA1063
+    {
+#pragma warning disable CS0420 // A reference to a volatile field will not be treated as volatile
+        var isDisposed = Interlocked.CompareExchange(ref _isDisposed, 1, 0);
+#pragma warning restore CS0420 // A reference to a volatile field will not be treated as volatile
+        if (isDisposed == 1)
+        {
+            return;
+        }
+
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    /// <summary>
+    ///     Finalizes an instance of the <see cref="Disposable" /> class.
+    /// </summary>
+    [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+#pragma warning disable CA1063
+    ~Disposable()
+#pragma warning restore CA1063
+    {
+#pragma warning disable CS0420 // A reference to a volatile field will not be treated as volatile
+        var isDisposed = Interlocked.CompareExchange(ref _isDisposed, 1, 0);
+#pragma warning restore CS0420 // A reference to a volatile field will not be treated as volatile
+        if (isDisposed == 1)
+        {
+            return;
+        }
+
+        Dispose(false);
+    }
+
+    /// <summary>
+    ///     Performs tasks related to freeing, releasing, or resetting unmanaged resources.
+    /// </summary>
+    /// <param name="isDisposing">
+    ///     <c>true</c> if <see cref="Dispose()" /> was called explicitly. <c>false</c> if
+    ///     <see cref="Dispose()" /> was called implicitly by the garbage collector finalizer.
+    /// </param>
+    [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+    protected abstract void Dispose(bool isDisposing);
+}
+
+/// <summary>
+///     Represents an object instance that is associated with an unmanaged handle.
+/// </summary>
+public abstract class NativeHandle : Disposable
+{
+    /// <summary>
+    ///     Gets or sets the unmanaged handle associated with the object instance.
+    /// </summary>
+    /// <remarks>
+    ///     <para>
+    ///         <see cref="Handle" /> is <see cref="IntPtr.Zero" /> when <see cref="Disposable.IsDisposed" /> is
+    ///         <c>true</c>.
+    ///     </para>
+    /// </remarks>
+    public IntPtr Handle { get; protected set; }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="NativeHandle"/> class.
+    /// </summary>
+    /// <param name="handle">The native handle.</param>
+    protected NativeHandle(IntPtr handle)
+    {
+        Handle = handle;
+    }
+
+    /// <inheritdoc />
+    protected override void Dispose(bool isDisposing)
+    {
+        Handle = IntPtr.Zero;
+    }
+}
diff --git a/src/cs/examples/helloworld/helloworld-app/Generated/my_c_library.g.cs b/src/cs/examples/helloworld/helloworld-app/Generated/my_c_library.g.cs
@@ -1,5 +1,5 @@
 // <auto-generated>
-//  This code was generated by the following tool on 2025-01-27 02:11:24 GMT-05:00:
+//  This code was generated by the following tool on 2025-02-19 20:34:32 GMT-05:00:
 //      https://github.com/bottlenoselabs/c2cs (v0.0.0.0)
 //
 //  Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.

diff --git a/src/cs/production/Interop.Runtime/ArenaNativeAllocator.cs b/src/cs/production/Interop.Runtime/ArenaNativeAllocator.cs
@@ -10,11 +10,11 @@ namespace Interop.Runtime;
 ///     An allocator that uses a single block of native memory which can be re-used.
 /// </summary>
 /// <remarks>
-///     <p>
+///     <para>
 ///         The <see cref="ArenaNativeAllocator" /> can be useful in native interoperability situations when you need to
 ///         temporarily allocate memory. For example, when calling native functions sometimes memory needs be available
 ///         for one or more calls but is no longer used after.
-///     </p>
+///     </para>
 /// </remarks>
 public sealed unsafe class ArenaNativeAllocator
     : INativeAllocator, IDisposable
@@ -106,10 +106,10 @@ public void Free(IntPtr pointer)
     ///     Resets <see cref="Used" /> to zero and clears the entire underlying block of native memory with zeroes.
     /// </summary>
     /// <remarks>
-    ///     <p>
+    ///     <para>
     ///         Any pointers returned from <see cref="Allocate" /> before calling <see cref="Reset" /> must not be used or else
     ///         there is a risk that the pointers point to unexpected bytes of data.
-    ///     </p>
+    ///     </para>
     /// </remarks>
     public void Reset()
     {

diff --git a/src/cs/production/Interop.Runtime/NativeHandle.cs b/src/cs/production/Interop.Runtime/NativeHandle.cs
@@ -11,17 +11,21 @@ namespace Interop.Runtime;
 public abstract class NativeHandle : Disposable
 {
     /// <summary>
-    ///     Gets the unmanaged handle associated with the object instance.
+    ///     Gets or sets the unmanaged handle associated with the object instance.
     /// </summary>
     /// <remarks>
     ///     <para>
     ///         <see cref="Handle" /> is <see cref="IntPtr.Zero" /> when <see cref="Disposable.IsDisposed" /> is
     ///         <c>true</c>.
     ///     </para>
     /// </remarks>
-    public IntPtr Handle { get; internal set; }
+
2E87
    public IntPtr Handle { get; protected set; }
 
-    internal NativeHandle(IntPtr handle)
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="NativeHandle"/> class.
+    /// </summary>
+    /// <param name="handle">The native handle.</param>
+    protected NativeHandle(IntPtr handle)
     {
         Handle = handle;
     }