Clean-up and take advantage of newer .NET APIs. (#556)

teo-tsirpanis · web-flow · commit 6256ed2c92d8 · 2025-05-08T16:46:54.000+03:00
* Remove unused class.

* Use non-boxing generic `Enum` APIs.

* Use `NativeMemory.Alloc` to allocate native memory.
diff --git a/sources/TileDB.CSharp/Context.cs b/sources/TileDB.CSharp/Context.cs
@@ -146,13 +146,13 @@ public string LastError()
             }
             else
             {
-                var message = Enum.IsDefined(typeof(Status), status) ? ((Status)status).ToString() : ("Unknown error with code:" + status);
+                var message = Enum.IsDefined((Status)status) ? ((Status)status).ToString() : ("Unknown error with code:" + status);
                 sb_result.Append(" Context.last_error,caught exception:" + message);
             }
         }
         else
         {
-            var message = Enum.IsDefined(typeof(Status), status) ? ((Status)status).ToString() : ("Unknown error with code:" + status);
+            var message = Enum.IsDefined((Status)status) ? ((Status)status).ToString() : ("Unknown error with code:" + status);
             sb_result.Append(" Context.last_error,caught exception:" + message);
         }
         Methods.tiledb_error_free(&p_tiledb_error);
diff --git a/sources/TileDB.CSharp/Marshalling/MarshaledContiguousStringCollection.cs b/sources/TileDB.CSharp/Marshalling/MarshaledContiguousStringCollection.cs
@@ -21,7 +21,7 @@ public MarshaledContiguousStringCollection(IReadOnlyCollection<string> strings,
         Encoding encoding = MarshaledString.GetEncoding(dataType);
         try
         {
-            Offsets = (ulong*)Marshal.AllocHGlobal(strings.Count * sizeof(ulong));
+            Offsets = (ulong*)NativeMemory.Alloc((nuint)strings.Count, sizeof(ulong));
             OffsetsCount = (ulong)strings.Count * sizeof(ulong);
             ulong currentOffset = 0;
             DataCount = 0;
@@ -31,7 +31,7 @@ public MarshaledContiguousStringCollection(IReadOnlyCollection<string> strings,
                 DataCount += (ulong)encoding.GetByteCount(str);
             }
 
-            Data = (byte*)Marshal.AllocHGlobal((IntPtr)DataCount);
+            Data = (byte*)NativeMemory.Alloc((nuint)DataCount);
             int i = 0;
             foreach (var str in strings)
             {
@@ -51,13 +51,13 @@ public void Dispose()
     {
         if (Data is not null)
         {
-            Marshal.FreeHGlobal((IntPtr)Data);
+            NativeMemory.Free(Data);
             Data = null;
             DataCount = 0;
         }
         if (Offsets is not null)
         {
-            Marshal.FreeHGlobal((IntPtr)Offsets);
+            NativeMemory.Free(Offsets);
             Offsets = null;
             OffsetsCount = 0;
         }
diff --git a/sources/TileDB.CSharp/Marshalling/MarshaledString.cs b/sources/TileDB.CSharp/Marshalling/MarshaledString.cs
@@ -15,8 +15,8 @@ public unsafe struct MarshaledString : IDisposable
 {
     public MarshaledString(string input)
     {
-        (IntPtr ptr, Length) = AllocNullTerminated(input);
-        Value = (sbyte*)ptr;
+        Value = AllocNullTerminated(input, out int length);
+        Length = length;
     }
 
     internal static Encoding GetEncoding(DataType dataType)
@@ -36,22 +36,23 @@ internal static Encoding GetEncoding(DataType dataType)
         return null;
     }
 
-    internal static (IntPtr Pointer, int Length) AllocNullTerminated(string str)
+    internal static sbyte* AllocNullTerminated(string str, out int length)
     {
         if (str is null)
         {
-            return ((IntPtr)0, 0);
+            length = 0;
+            return null;
         }
 
-        int length = Encoding.ASCII.GetByteCount(str);
-        var ptr = (sbyte*)Marshal.AllocHGlobal(length + 1);
+        length = Encoding.ASCII.GetByteCount(str);
+        var ptr = (sbyte*)NativeMemory.Alloc((nuint)length + 1);
         int bytesWritten = Encoding.ASCII.GetBytes(str, new Span<byte>(ptr, length));
         Debug.Assert(bytesWritten == length);
         ptr[length] = 0;
-        return ((IntPtr)ptr, length);
+        return ptr;
     }
 
-    internal static void FreeNullTerminated(IntPtr ptr) => Marshal.FreeHGlobal(ptr);
+    internal static void FreeNullTerminated(void* ptr) => NativeMemory.Free(ptr);
 
     public ReadOnlySpan<byte> AsSpan() => new ReadOnlySpan<byte>(Value, Length);
 
@@ -63,7 +64,7 @@ public void Dispose()
     {
         if (Value != null)
         {
-            Marshal.FreeHGlobal((IntPtr)Value);
+            NativeMemory.Free(Value);
             Value = null;
             Length = 0;
         }
diff --git a/sources/TileDB.CSharp/Marshalling/MarshaledStringCollection.cs b/sources/TileDB.CSharp/Marshalling/MarshaledStringCollection.cs
@@ -7,20 +7,20 @@ namespace TileDB.CSharp.Marshalling;
 
 internal unsafe ref struct MarshaledStringCollection
 {
-    public IntPtr* Strings { get; private set; }
+    public sbyte** Strings { get; private set; }
 
     public int Count { get; }
 
     public MarshaledStringCollection(IReadOnlyList<string> strings)
     {
         Count = strings.Count;
-        Strings = (IntPtr*)Marshal.AllocHGlobal(Count * sizeof(IntPtr));
+        Strings = (sbyte**)NativeMemory.Alloc((nuint)Count, (nuint)sizeof(sbyte*));
 
         try
         {
             for (int i = 0; i < Count; i++)
             {
-                Strings[i] = MarshaledString.AllocNullTerminated(strings[i]).Pointer;
+                Strings[i] = MarshaledString.AllocNullTerminated(strings[i], out _);
             }
         }
         catch
@@ -38,7 +38,7 @@ public void Dispose()
         {
             MarshaledString.FreeNullTerminated(Strings[i]);
         }
-        Marshal.FreeHGlobal((IntPtr)Strings);
+        NativeMemory.Free(Strings);
         Strings = null;
     }
 }
diff --git a/sources/TileDB.CSharp/Marshalling/SafeHandles/QueryHandle.cs b/sources/TileDB.CSharp/Marshalling/SafeHandles/QueryHandle.cs
@@ -282,7 +282,7 @@ public BufferHandle(ref MemoryHandle handle, ulong size, int elementSize)
             bool successful = false;
             try
             {
-                SizePointer = (ulong*)Marshal.AllocHGlobal(sizeof(ulong));
+                SizePointer = (ulong*)NativeMemory.Alloc(1, sizeof(ulong));
                 successful = true;
             }
             finally
@@ -300,7 +300,7 @@ public void Dispose()
             DataHandle.Dispose();
             if (SizePointer != null)
             {
-                Marshal.FreeHGlobal((IntPtr)SizePointer);
+                NativeMemory.Free(SizePointer);
             }
             SizePointer = null;
         }
diff --git a/sources/TileDB.CSharp/Query.cs b/sources/TileDB.CSharp/Query.cs
@@ -965,60 +965,4 @@ private void CheckDataType<T>(string name)
     /// <exception cref="KeyNotFoundException">No validity buffer has
     /// been registered with <paramref name="name"/>.</exception>
     public ulong GetResultValidities(string name) => _handle.GetResultValidities(name);
-
-    private sealed class BufferHandle : IDisposable
-    {
-        private readonly int _elementSize;
-
-        private MemoryHandle DataHandle;
-
-        public ulong* SizePointer { get; private set; }
-
-        public void* DataPointer => DataHandle.Pointer;
-
-        public ulong SizeInBytes => *SizePointer;
-
-        public ulong SizeInElements
-        {
-            get
-            {
-                if (_elementSize == 0)
-                {
-                    ThrowHelpers.ThrowBufferUnsafelySet();
-                }
-                return *SizePointer / (ulong)_elementSize;
-            }
-        }
-
-        public BufferHandle(ref MemoryHandle handle, ulong size, int elementSize)
-        {
-            DataHandle = handle;
-            handle = default;
-            _elementSize = elementSize;
-            bool successful = false;
-            try
-            {
-                SizePointer = (ulong*)Marshal.AllocHGlobal(sizeof(ulong));
-                successful = true;
-            }
-            finally
-            {
-                if (!successful)
-                {
-                    DataHandle.Dispose();
-                }
-            }
-            *SizePointer = size;
-        }
-
-        public void Dispose()
-        {
-            DataHandle.Dispose();
-            if (SizePointer != null)
-            {
-                Marshal.FreeHGlobal((IntPtr)SizePointer);
-            }
-            SizePointer = null;
-        }
-    }
 }

Original file line number	Diff line number	Diff line change
`@@ -146,13 +146,13 @@ public string LastError()`
`146`	`146`	`}`
`147`	`147`	`else`
`148`	`148`	`{`
`149`		`- var message = Enum.IsDefined(typeof(Status), status) ? ((Status)status).ToString() : ("Unknown error with code:" + status);`
	`149`	`+ var message = Enum.IsDefined((Status)status) ? ((Status)status).ToString() : ("Unknown error with code:" + status);`
`150`	`150`	`sb_result.Append(" Context.last_error,caught exception:" + message);`
`151`	`151`	`}`
`152`	`152`	`}`
`153`	`153`	`else`
`154`	`154`	`{`
`155`		`- var message = Enum.IsDefined(typeof(Status), status) ? ((Status)status).ToString() : ("Unknown error with code:" + status);`
	`155`	`+ var message = Enum.IsDefined((Status)status) ? ((Status)status).ToString() : ("Unknown error with code:" + status);`
`156`	`156`	`sb_result.Append(" Context.last_error,caught exception:" + message);`
`157`	`157`	`}`
`158`	`158`	`Methods.tiledb_error_free(&p_tiledb_error);`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ public MarshaledContiguousStringCollection(IReadOnlyCollection<string> strings,`
`21`	`21`	`Encoding encoding = MarshaledString.GetEncoding(dataType);`
`22`	`22`	`try`
`23`	`23`	`{`
`24`		`- Offsets = (ulong)Marshal.AllocHGlobal(strings.Count sizeof(ulong));`
	`24`	`+ Offsets = (ulong*)NativeMemory.Alloc((nuint)strings.Count, sizeof(ulong));`
`25`	`25`	`OffsetsCount = (ulong)strings.Count * sizeof(ulong);`
`26`	`26`	`ulong currentOffset = 0;`
`27`	`27`	`DataCount = 0;`
`@@ -31,7 +31,7 @@ public MarshaledContiguousStringCollection(IReadOnlyCollection<string> strings,`
`31`	`31`	`DataCount += (ulong)encoding.GetByteCount(str);`
`32`	`32`	`}`
`33`	`33`
`34`		`- Data = (byte*)Marshal.AllocHGlobal((IntPtr)DataCount);`
	`34`	`+ Data = (byte*)NativeMemory.Alloc((nuint)DataCount);`
`35`	`35`	`int i = 0;`
`36`	`36`	`foreach (var str in strings)`
`37`	`37`	`{`
`@@ -51,13 +51,13 @@ public void Dispose()`
`51`	`51`	`{`
`52`	`52`	`if (Data is not null)`
`53`	`53`	`{`
`54`		`- Marshal.FreeHGlobal((IntPtr)Data);`
	`54`	`+ NativeMemory.Free(Data);`
`55`	`55`	`Data = null;`
`56`	`56`	`DataCount = 0;`
`57`	`57`	`}`
`58`	`58`	`if (Offsets is not null)`
`59`	`59`	`{`
`60`		`- Marshal.FreeHGlobal((IntPtr)Offsets);`
	`60`	`+ NativeMemory.Free(Offsets);`
`61`	`61`	`Offsets = null;`
`62`	`62`	`OffsetsCount = 0;`
`63`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,8 +15,8 @@ public unsafe struct MarshaledString : IDisposable`
`15`	`15`	`{`
`16`	`16`	`public MarshaledString(string input)`
`17`	`17`	`{`
`18`		`- (IntPtr ptr, Length) = AllocNullTerminated(input);`
`19`		`- Value = (sbyte*)ptr;`
	`18`	`+ Value = AllocNullTerminated(input, out int length);`
	`19`	`+ Length = length;`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`internal static Encoding GetEncoding(DataType dataType)`
`@@ -36,22 +36,23 @@ internal static Encoding GetEncoding(DataType dataType)`
`36`	`36`	`return null;`
`37`	`37`	`}`
`38`	`38`
`39`		`- internal static (IntPtr Pointer, int Length) AllocNullTerminated(string str)`
	`39`	`+ internal static sbyte* AllocNullTerminated(string str, out int length)`
`40`	`40`	`{`
`41`	`41`	`if (str is null)`
`42`	`42`	`{`
`43`		`- return ((IntPtr)0, 0);`
	`43`	`+ length = 0;`
	`44`	`+ return null;`
`44`	`45`	`}`
`45`	`46`
`46`		`- int length = Encoding.ASCII.GetByteCount(str);`
`47`		`- var ptr = (sbyte*)Marshal.AllocHGlobal(length + 1);`
	`47`	`+ length = Encoding.ASCII.GetByteCount(str);`
	`48`	`+ var ptr = (sbyte*)NativeMemory.Alloc((nuint)length + 1);`
`48`	`49`	`int bytesWritten = Encoding.ASCII.GetBytes(str, new Span<byte>(ptr, length));`
`49`	`50`	`Debug.Assert(bytesWritten == length);`
`50`	`51`	`ptr[length] = 0;`
`51`		`- return ((IntPtr)ptr, length);`
	`52`	`+ return ptr;`
`52`	`53`	`}`
`53`	`54`
`54`		`- internal static void FreeNullTerminated(IntPtr ptr) => Marshal.FreeHGlobal(ptr);`
	`55`	`+ internal static void FreeNullTerminated(void* ptr) => NativeMemory.Free(ptr);`
`55`	`56`
`56`	`57`	`public ReadOnlySpan<byte> AsSpan() => new ReadOnlySpan<byte>(Value, Length);`
`57`	`58`
`@@ -63,7 +64,7 @@ public void Dispose()`
`63`	`64`	`{`
`64`	`65`	`if (Value != null)`
`65`	`66`	`{`
`66`		`- Marshal.FreeHGlobal((IntPtr)Value);`
	`67`	`+ NativeMemory.Free(Value);`
`67`	`68`	`Value = null;`
`68`	`69`	`Length = 0;`
`69`	`70`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,20 +7,20 @@ namespace TileDB.CSharp.Marshalling;`
`7`	`7`
`8`	`8`	`internal unsafe ref struct MarshaledStringCollection`
`9`	`9`	`{`
`10`		`- public IntPtr* Strings { get; private set; }`
	`10`	`+ public sbyte** Strings { get; private set; }`
`11`	`11`
`12`	`12`	`public int Count { get; }`
`13`	`13`
`14`	`14`	`public MarshaledStringCollection(IReadOnlyList<string> strings)`
`15`	`15`	`{`
`16`	`16`	`Count = strings.Count;`
`17`		`- Strings = (IntPtr)Marshal.AllocHGlobal(Count sizeof(IntPtr));`
	`17`	`+ Strings = (sbyte*)NativeMemory.Alloc((nuint)Count, (nuint)sizeof(sbyte));`
`18`	`18`
`19`	`19`	`try`
`20`	`20`	`{`
`21`	`21`	`for (int i = 0; i < Count; i++)`
`22`	`22`	`{`
`23`		`- Strings[i] = MarshaledString.AllocNullTerminated(strings[i]).Pointer;`
	`23`	`+ Strings[i] = MarshaledString.AllocNullTerminated(strings[i], out _);`
`24`	`24`	`}`
`25`	`25`	`}`
`26`	`26`	`catch`
`@@ -38,7 +38,7 @@ public void Dispose()`
`38`	`38`	`{`
`39`	`39`	`MarshaledString.FreeNullTerminated(Strings[i]);`
`40`	`40`	`}`
`41`		`- Marshal.FreeHGlobal((IntPtr)Strings);`
	`41`	`+ NativeMemory.Free(Strings);`
`42`	`42`	`Strings = null;`
`43`	`43`	`}`
`44`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -282,7 +282,7 @@ public BufferHandle(ref MemoryHandle handle, ulong size, int elementSize)`
`282`	`282`	`bool successful = false;`
`283`	`283`	`try`
`284`	`284`	`{`
`285`		`- SizePointer = (ulong*)Marshal.AllocHGlobal(sizeof(ulong));`
	`285`	`+ SizePointer = (ulong*)NativeMemory.Alloc(1, sizeof(ulong));`
`286`	`286`	`successful = true;`
`287`	`287`	`}`
`288`	`288`	`finally`
`@@ -300,7 +300,7 @@ public void Dispose()`
`300`	`300`	`DataHandle.Dispose();`
`301`	`301`	`if (SizePointer != null)`
`302`	`302`	`{`
`303`		`- Marshal.FreeHGlobal((IntPtr)SizePointer);`
	`303`	`+ NativeMemory.Free(SizePointer);`
`304`	`304`	`}`
`305`	`305`	`SizePointer = null;`
`306`	`306`	`}`