diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml
index ad63f15e..f0c293b8 100644
--- a/.github/workflows/nightly.yml
+++ b/.github/workflows/nightly.yml
@@ -27,7 +27,7 @@ jobs:
           - os: windows-latest
             platform: windows-x86_64
           - tag: dev
-        tag: [release-2.25, dev]
+        tag: [release-2.26, dev]
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout TileDB
@@ -71,7 +71,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        tag: [release-2.25, dev]
+        tag: [release-2.26, dev]
     runs-on: ubuntu-latest
     steps:
       - name: Checkout TileDB-CSharp
@@ -112,7 +112,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        tag: [release-2.25, dev]
+        tag: [release-2.26, dev]
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout TileDB-CSharp
diff --git a/Directory.Packages.props b/Directory.Packages.props
index 64ebb9c4..fc363b62 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -3,7 +3,7 @@
     <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
     <TileDBNativePackageName>TileDB.Native</TileDBNativePackageName>
     <TileDBNativeVersionMajor>2</TileDBNativeVersionMajor>
-    <TileDBNativeVersionMinor>25</TileDBNativeVersionMinor>
+    <TileDBNativeVersionMinor>26</TileDBNativeVersionMinor>
     <TileDBNativePackageVersion>[$(TileDBNativeVersionMajor).$(TileDBNativeVersionMinor).0,$(TileDBNativeVersionMajor).$([MSBuild]::Add($(TileDBNativeVersionMinor), 1)).0)</TileDBNativePackageVersion>
 
     <!-- The DevelopmentBuild property switches to the locally built native packages.
diff --git a/sources/TileDB.CSharp/ArraySchema.cs b/sources/TileDB.CSharp/ArraySchema.cs
index 4a3250d4..8208a583 100644
--- a/sources/TileDB.CSharp/ArraySchema.cs
+++ b/sources/TileDB.CSharp/ArraySchema.cs
@@ -6,6 +6,7 @@
 using FilterListHandle = TileDB.CSharp.Marshalling.SafeHandles.FilterListHandle;
 using DomainHandle = TileDB.CSharp.Marshalling.SafeHandles.DomainHandle;
 using AttributeHandle = TileDB.CSharp.Marshalling.SafeHandles.AttributeHandle;
+using TileDB.CSharp.Marshalling;
 
 namespace TileDB.CSharp;
 
@@ -595,4 +596,14 @@ public bool IsVarSize(string name)
 
         return false;
     }
+
+    /// <inheritdoc/>
+    public override string ToString()
+    {
+        using var ctx = _ctx.Handle.Acquire();
+        using var handle = _handle.Acquire();
+        using var strPtr = new StringHandleHolder();
+        _ctx.handle_error(Methods.tiledb_array_schema_dump_str(ctx, handle, &strPtr._handle));
+        return strPtr.ToString();
+    }
 }
diff --git a/sources/TileDB.CSharp/Attribute.cs b/sources/TileDB.CSharp/Attribute.cs
index 48418e92..0144fb5e 100644
--- a/sources/TileDB.CSharp/Attribute.cs
+++ b/sources/TileDB.CSharp/Attribute.cs
@@ -440,4 +440,14 @@ public static Attribute Create<T>(Context ctx, string name)
         var datatype = EnumUtil.TypeToDataType(typeof(T));
         return new Attribute(ctx, name, datatype);
     }
+
+    /// <inheritdoc/>
+    public override string ToString()
+    {
+        using var ctx = _ctx.Handle.Acquire();
+        using var handle = _handle.Acquire();
+        using var strPtr = new StringHandleHolder();
+        _ctx.handle_error(Methods.tiledb_attribute_dump_str(ctx, handle, &strPtr._handle));
+        return strPtr.ToString();
+    }
 }
diff --git a/sources/TileDB.CSharp/Dimension.cs b/sources/TileDB.CSharp/Dimension.cs
index 2fc89606..3a8a1aaa 100644
--- a/sources/TileDB.CSharp/Dimension.cs
+++ b/sources/TileDB.CSharp/Dimension.cs
@@ -258,4 +258,14 @@ public static Dimension CreateString(Context ctx, string name)
         var str_dim_handle = DimensionHandle.Create(ctx, name, tiledb_datatype_t.TILEDB_STRING_ASCII, null, null);
         return new Dimension(ctx, str_dim_handle);
     }
+
+    /// <inheritdoc/>
+    public override string ToString()
+    {
+        using var ctx = _ctx.Handle.Acquire();
+        using var handle = _handle.Acquire();
+        using var strPtr = new StringHandleHolder();
+        _ctx.handle_error(Methods.tiledb_dimension_dump_str(ctx, handle, &strPtr._handle));
+        return strPtr.ToString();
+    }
 }
diff --git a/sources/TileDB.CSharp/Domain.cs b/sources/TileDB.CSharp/Domain.cs
index e7de4455..e7a7d168 100644
--- a/sources/TileDB.CSharp/Domain.cs
+++ b/sources/TileDB.CSharp/Domain.cs
@@ -3,6 +3,7 @@
 using TileDB.Interop;
 using DomainHandle = TileDB.CSharp.Marshalling.SafeHandles.DomainHandle;
 using DimensionHandle = TileDB.CSharp.Marshalling.SafeHandles.DimensionHandle;
+using TileDB.CSharp.Marshalling;
 
 namespace TileDB.CSharp;
 
@@ -176,5 +177,16 @@ public bool HasDimension(string name)
         _ctx.handle_error(Methods.tiledb_domain_has_dimension(ctxHandle, handle, ms_name, &has_dim));
         return has_dim > 0;
     }
+    
+
+    /// <inheritdoc/>
+    public override string ToString()
+    {
+        using var ctx = _ctx.Handle.Acquire();
+        using var handle = _handle.Acquire();
+        using var strPtr = new StringHandleHolder();
+        _ctx.handle_error(Methods.tiledb_domain_dump_str(ctx, handle, &strPtr._handle));
+        return strPtr.ToString();
+    }
     #endregion
 }
diff --git a/sources/TileDB.CSharp/Enumeration.cs b/sources/TileDB.CSharp/Enumeration.cs
index cc3c60f3..2dcd9e41 100644
--- a/sources/TileDB.CSharp/Enumeration.cs
+++ b/sources/TileDB.CSharp/Enumeration.cs
@@ -384,4 +384,14 @@ public ulong[] GetRawOffsets()
         _ctx.handle_error(Methods.tiledb_enumeration_get_offsets(ctxHandle, handle, &data, &dataSize));
         return new ReadOnlySpan<ulong>(data, checked((int)(dataSize / sizeof(ulong)))).ToArray();
     }
+
+    /// <inheritdoc/>
+    public override string ToString()
+    {
+        using var ctx = _ctx.Handle.Acquire();
+        using var handle = _handle.Acquire();
+        using var strPtr = new StringHandleHolder();
+        _ctx.handle_error(Methods.tiledb_enumeration_dump_str(ctx, handle, &strPtr._handle));
+        return strPtr.ToString();
+    }
 }
diff --git a/sources/TileDB.CSharp/Interop/Methods.cs b/sources/TileDB.CSharp/Interop/Methods.cs
index e34185c4..86979765 100644
--- a/sources/TileDB.CSharp/Interop/Methods.cs
+++ b/sources/TileDB.CSharp/Interop/Methods.cs
@@ -241,6 +241,10 @@ public static int tiledb_status([NativeTypeName("capi_return_t")] int x)
         [return: NativeTypeName("int32_t")]
         public static extern int tiledb_attribute_get_cell_size(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_attribute_t *")] tiledb_attribute_t* attr, [NativeTypeName("uint64_t *")] ulong* cell_size);
 
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_attribute_dump_str(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_attribute_t *")] tiledb_attribute_t* attr, tiledb_string_t** @out);
+
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("int32_t")]
         public static extern int tiledb_attribute_set_fill_value(tiledb_ctx_t* ctx, tiledb_attribute_t* attr, [NativeTypeName("const void *")] void* value, [NativeTypeName("uint64_t")] ulong size);
@@ -350,6 +354,10 @@ public static int tiledb_status([NativeTypeName("capi_return_t")] int x)
         [return: NativeTypeName("int32_t")]
         public static extern int tiledb_dimension_get_tile_extent(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_dimension_t *")] tiledb_dimension_t* dim, [NativeTypeName("const void **")] void** tile_extent);
 
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_dimension_dump_str(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_dimension_t *")] tiledb_dimension_t* dimension, tiledb_string_t** @out);
+
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("int32_t")]
         public static extern int tiledb_domain_alloc(tiledb_ctx_t* ctx, tiledb_domain_t** domain);
@@ -381,6 +389,10 @@ public static int tiledb_status([NativeTypeName("capi_return_t")] int x)
         [return: NativeTypeName("int32_t")]
         public static extern int tiledb_domain_has_dimension(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_domain_t *")] tiledb_domain_t* domain, [NativeTypeName("const char *")] sbyte* name, [NativeTypeName("int32_t *")] int* has_dim);
 
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_domain_dump_str(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_domain_t *")] tiledb_domain_t* domain, tiledb_string_t** @out);
+
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
         public static extern int tiledb_object_type_to_str(tiledb_object_t object_type, [NativeTypeName("const char **")] sbyte** str);
@@ -788,6 +800,10 @@ public static int tiledb_status([NativeTypeName("capi_return_t")] int x)
         [return: NativeTypeName("int32_t")]
         public static extern int tiledb_array_schema_has_attribute(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_array_schema_t *")] tiledb_array_schema_t* array_schema, [NativeTypeName("const char *")] sbyte* name, [NativeTypeName("int32_t *")] int* has_attr);
 
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_array_schema_dump_str(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_array_schema_t *")] tiledb_array_schema_t* array_schema, tiledb_string_t** @out);
+
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("int32_t")]
         public static extern int tiledb_query_alloc(tiledb_ctx_t* ctx, tiledb_array_t* array, tiledb_query_type_t query_type, tiledb_query_t** query);
@@ -1351,6 +1367,18 @@ public static int tiledb_status([NativeTypeName("capi_return_t")] int x)
         [return: NativeTypeName("capi_return_t")]
         public static extern int tiledb_ndrectangle_set_range(tiledb_ctx_t* ctx, [NativeTypeName("tiledb_ndrectangle_t *")] tiledb_ndrectangle_handle_t* ndr, [NativeTypeName("uint32_t")] uint idx, tiledb_range_t* range);
 
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_ndrectangle_get_dtype(tiledb_ctx_t* ctx, [NativeTypeName("tiledb_ndrectangle_t *")] tiledb_ndrectangle_handle_t* ndr, [NativeTypeName("uint32_t")] uint idx, tiledb_datatype_t* type);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_ndrectangle_get_dtype_from_name(tiledb_ctx_t* ctx, [NativeTypeName("tiledb_ndrectangle_t *")] tiledb_ndrectangle_handle_t* ndr, [NativeTypeName("const char *")] sbyte* name, tiledb_datatype_t* type);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_ndrectangle_get_dim_num(tiledb_ctx_t* ctx, [NativeTypeName("tiledb_ndrectangle_t *")] tiledb_ndrectangle_handle_t* ndr, [NativeTypeName("uint32_t *")] uint* ndim);
+
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
         public static extern int tiledb_current_domain_create(tiledb_ctx_t* ctx, [NativeTypeName("tiledb_current_domain_t **")] tiledb_current_domain_handle_t** current_domain);
@@ -1361,19 +1389,19 @@ public static int tiledb_status([NativeTypeName("capi_return_t")] int x)
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_current_domain_set_ndrectangle([NativeTypeName("tiledb_current_domain_t *")] tiledb_current_domain_handle_t* current_domain, [NativeTypeName("tiledb_ndrectangle_t *")] tiledb_ndrectangle_handle_t* ndr);
+        public static extern int tiledb_current_domain_set_ndrectangle(tiledb_ctx_t* ctx, [NativeTypeName("tiledb_current_domain_t *")] tiledb_current_domain_handle_t* current_domain, [NativeTypeName("tiledb_ndrectangle_t *")] tiledb_ndrectangle_handle_t* ndr);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_current_domain_get_ndrectangle([NativeTypeName("tiledb_current_domain_t *")] tiledb_current_domain_handle_t* current_domain, [NativeTypeName("tiledb_ndrectangle_t **")] tiledb_ndrectangle_handle_t** ndr);
+        public static extern int tiledb_current_domain_get_ndrectangle(tiledb_ctx_t* ctx, [NativeTypeName("tiledb_current_domain_t *")] tiledb_current_domain_handle_t* current_domain, [NativeTypeName("tiledb_ndrectangle_t **")] tiledb_ndrectangle_handle_t** ndr);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_current_domain_get_is_empty([NativeTypeName("tiledb_current_domain_t *")] tiledb_current_domain_handle_t* current_domain, [NativeTypeName("uint32_t *")] uint* is_empty);
+        public static extern int tiledb_current_domain_get_is_empty(tiledb_ctx_t* ctx, [NativeTypeName("tiledb_current_domain_t *")] tiledb_current_domain_handle_t* current_domain, [NativeTypeName("uint32_t *")] uint* is_empty);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_current_domain_get_type([NativeTypeName("tiledb_current_domain_t *")] tiledb_current_domain_handle_t* current_domain, tiledb_current_domain_type_t* type);
+        public static extern int tiledb_current_domain_get_type(tiledb_ctx_t* ctx, [NativeTypeName("tiledb_current_domain_t *")] tiledb_current_domain_handle_t* current_domain, tiledb_current_domain_type_t* type);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
@@ -1410,6 +1438,10 @@ public static int tiledb_status([NativeTypeName("capi_return_t")] int x)
         [return: NativeTypeName("capi_return_t")]
         public static extern int tiledb_enumeration_get_offsets(tiledb_ctx_t* ctx, tiledb_enumeration_t* enumeration, [NativeTypeName("const void **")] void** offsets, [NativeTypeName("uint64_t *")] ulong* offsets_size);
 
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_enumeration_dump_str(tiledb_ctx_t* ctx, tiledb_enumeration_t* enumeration, tiledb_string_t** @out);
+
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("int32_t")]
         public static extern int tiledb_channel_operator_sum_get(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_channel_operator_t **")] tiledb_channel_operator_t** op);
diff --git a/sources/TileDB.CSharp/TileDB.CSharp.csproj b/sources/TileDB.CSharp/TileDB.CSharp.csproj
index cbaba219..201b0523 100644
--- a/sources/TileDB.CSharp/TileDB.CSharp.csproj
+++ b/sources/TileDB.CSharp/TileDB.CSharp.csproj
@@ -6,12 +6,12 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <Nullable>enable</Nullable>
     <RootNamespace>TileDB.CSharp</RootNamespace>
-    <Version>5.15.0</Version>
+    <Version>5.16.0</Version>
     <Description>C# wrapper of the TileDB Embedded universal data engine.</Description>
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <EnablePackageValidation>true</EnablePackageValidation>
-    <PackageValidationBaselineVersion>5.14.0</PackageValidationBaselineVersion>
+    <PackageValidationBaselineVersion>5.15.0</PackageValidationBaselineVersion>
     <NoWarn>$(NoWarn);TILEDB0012;TILEDB0013;TILEDB0014</NoWarn>
   </PropertyGroup>
 
diff --git a/tests/TileDB.CSharp.Test/ArraySchemaTest.cs b/tests/TileDB.CSharp.Test/ArraySchemaTest.cs
index 51bffa31..b38183cb 100644
--- a/tests/TileDB.CSharp.Test/ArraySchemaTest.cs
+++ b/tests/TileDB.CSharp.Test/ArraySchemaTest.cs
@@ -3,70 +3,70 @@
 
 namespace TileDB.CSharp.Test;
 
-	[TestClass]
-	public class ArraySchemaTest
-	{
-		[TestMethod]
-		public void TestArraySchema()
-		{
-			var context = Context.GetDefault();
+[TestClass]
+public class ArraySchemaTest
+{
+    [TestMethod]
+    public void TestArraySchema()
+    {
+        var context = Context.GetDefault();
 
-			var dimension = Dimension.Create(context, "test", 1, 10, 5);
-			Assert.IsNotNull(dimension);
+        var dimension = Dimension.Create(context, "test", 1, 10, 5);
+        Assert.IsNotNull(dimension);
 
-			var domain = new Domain(context);
-			Assert.IsNotNull(domain);
+        var domain = new Domain(context);
+        Assert.IsNotNull(domain);
 
-			domain.AddDimension(dimension);
+        domain.AddDimension(dimension);
 
-			var array_schema = new ArraySchema(context, ArrayType.Dense);
-			Assert.IsNotNull(array_schema);
+        var array_schema = new ArraySchema(context, ArrayType.Dense);
+        Assert.IsNotNull(array_schema);
 
-			Assert.IsFalse(array_schema.AllowsDups());
+        Assert.IsFalse(array_schema.AllowsDups());
 
-			var attribute = new Attribute(context, "a1", DataType.Int32);
-			Assert.IsNotNull(attribute);
+        var attribute = new Attribute(context, "a1", DataType.Int32);
+        Assert.IsNotNull(attribute);
 
-			array_schema.AddAttribute(attribute);
+        array_schema.AddAttribute(attribute);
 
-			Assert.AreEqual((uint)1, array_schema.AttributeNum());
+        Assert.AreEqual((uint)1, array_schema.AttributeNum());
 
-			var attribute_from_index = array_schema.Attribute(0);
-			Assert.AreEqual("a1", attribute_from_index.Name());
+        var attribute_from_index = array_schema.Attribute(0);
+        Assert.AreEqual("a1", attribute_from_index.Name());
 
-			var attribute_from_name = array_schema.Attribute("a1");
-			Assert.AreEqual("a1", attribute_from_name.Name());
+        var attribute_from_name = array_schema.Attribute("a1");
+        Assert.AreEqual("a1", attribute_from_name.Name());
 
-			Assert.IsTrue(array_schema.HasAttribute("a1"));
+        Assert.IsTrue(array_schema.HasAttribute("a1"));
 
-			array_schema.SetCapacity(100);
-			Assert.AreEqual((ulong)100, array_schema.Capacity());
+        array_schema.SetCapacity(100);
+        Assert.AreEqual((ulong)100, array_schema.Capacity());
 
-			array_schema.SetDomain(domain);
+        array_schema.SetDomain(domain);
 
-			var d = array_schema.Domain();
-			Assert.IsNotNull(d);
+        var d = array_schema.Domain();
+        Assert.IsNotNull(d);
 
-			Assert.AreEqual((ulong)1, d.NDim());
-			Assert.AreEqual(DataType.Int32, d.Type());
+        Assert.AreEqual((ulong)1, d.NDim());
+        Assert.AreEqual(DataType.Int32, d.Type());
 
-			array_schema.SetCellOrder(LayoutType.GlobalOrder);
-			Assert.AreEqual(LayoutType.GlobalOrder, array_schema.CellOrder());
+        array_schema.SetCellOrder(LayoutType.GlobalOrder);
+        Assert.AreEqual(LayoutType.GlobalOrder, array_schema.CellOrder());
 
-			array_schema.SetTileOrder(LayoutType.ColumnMajor);
-			Assert.AreEqual(LayoutType.ColumnMajor, array_schema.TileOrder());
+        array_schema.SetTileOrder(LayoutType.ColumnMajor);
+        Assert.AreEqual(LayoutType.ColumnMajor, array_schema.TileOrder());
 
-			using var filter = new Filter(context, FilterType.Bzip2);
-			Assert.AreEqual(FilterType.Bzip2, filter.FilterType());
+        using var filter = new Filter(context, FilterType.Bzip2);
+        Assert.AreEqual(FilterType.Bzip2, filter.FilterType());
 
-			using var filter_list = new FilterList(context);
-			filter_list.AddFilter(filter);
+        using var filter_list = new FilterList(context);
+        filter_list.AddFilter(filter);
 
-			array_schema.SetCoordsFilterList(filter_list);
-			var filter_list_return = array_schema.CoordsFilterList();
+        array_schema.SetCoordsFilterList(filter_list);
+        var filter_list_return = array_schema.CoordsFilterList();
 
-			var filter0 = filter_list_return.Filter(0);
-			Assert.AreEqual(FilterType.Bzip2, filter0.FilterType());
+        var filter0 = filter_list_return.Filter(0);
+        Assert.AreEqual(FilterType.Bzip2, filter0.FilterType());
 
         array_schema.SetOffsetsFilterList(filter_list);
         filter_list_return = array_schema.OffsetsFilterList();
@@ -80,197 +80,204 @@ public void TestArraySchema()
         filter0 = filter_list_return.Filter(0);
         Assert.AreEqual(FilterType.Bzip2, filter0.FilterType());
 
+        // ToString() will call tiledb_array_schema_dump_str, which will return an informative string.
+        // Because the string's format is unspecified, we cannot fully parse it so we just check if
+        // it contains something it should definitely contain. The same applies to the other objects
+        // that can be dumped.
+        var dump = array_schema.ToString();
+        Assert.IsTrue(dump.Contains(nameof(ArrayType.Dense), StringComparison.OrdinalIgnoreCase));
+
         array_schema.Check();
-		}
+    }
 
-		[TestMethod]
-		public void TestArraySchemaInt32Simple()
+    [TestMethod]
+    public void TestArraySchemaInt32Simple()
     {
-			var context = Context.GetDefault();
-			var domain = new Domain(context);
-			Assert.IsNotNull(domain);
+        var context = Context.GetDefault();
+        var domain = new Domain(context);
+        Assert.IsNotNull(domain);
 
-			var dim_rows = Dimension.Create(context, "rows", 0, 4, 4);
-			Assert.IsNotNull(dim_rows);
-			domain.AddDimension(dim_rows);
+        var dim_rows = Dimension.Create(context, "rows", 0, 4, 4);
+        Assert.IsNotNull(dim_rows);
+        domain.AddDimension(dim_rows);
 
-			var dim_cols = Dimension.Create(context, "cols", 0, 4, 4);
-			Assert.IsNotNull(dim_cols);
-			domain.AddDimension(dim_cols);
+        var dim_cols = Dimension.Create(context, "cols", 0, 4, 4);
+        Assert.IsNotNull(dim_cols);
+        domain.AddDimension(dim_cols);
 
-			var array_schema = new ArraySchema(context, ArrayType.Dense);
-			Assert.IsNotNull(array_schema);
+        var array_schema = new ArraySchema(context, ArrayType.Dense);
+        Assert.IsNotNull(array_schema);
 
-			var attr1 = new Attribute(context, "a", DataType.Int32);
-			Assert.IsNotNull(attr1);
+        var attr1 = new Attribute(context, "a", DataType.Int32);
+        Assert.IsNotNull(attr1);
 
-			array_schema.AddAttribute(attr1);
+        array_schema.AddAttribute(attr1);
 
-			array_schema.SetDomain(domain);
+        array_schema.SetDomain(domain);
 
-			array_schema.Check();
+        array_schema.Check();
 
-		}
+    }
 
-		[TestMethod]
-		public void TestArraySchemaInt32Hilbert()
-		{
-			var config = new Config();
-			var context = new Context(config);
+    [TestMethod]
+    public void TestArraySchemaInt32Hilbert()
+    {
+        var config = new Config();
+        var context = new Context(config);
 
-			var d1 = Dimension.Create(context, "d1", 0, 100, 5);
-			Assert.IsNotNull(d1);
+        var d1 = Dimension.Create(context, "d1", 0, 100, 5);
+        Assert.IsNotNull(d1);
 
-			var d2 = Dimension.Create(context, "d2", 0, 200, 5);
-			Assert.IsNotNull(d1);
+        var d2 = Dimension.Create(context, "d2", 0, 200, 5);
+        Assert.IsNotNull(d1);
 
-			var domain = new Domain(context);
-			Assert.IsNotNull(domain);
+        var domain = new Domain(context);
+        Assert.IsNotNull(domain);
 
-			domain.AddDimensions(d1, d2);
+        domain.AddDimensions(d1, d2);
 
-			var array_schema = new ArraySchema(context, ArrayType.Sparse);
-			Assert.IsNotNull(array_schema);
+        var array_schema = new ArraySchema(context, ArrayType.Sparse);
+        Assert.IsNotNull(array_schema);
 
-			var a1 = new Attribute(context, "a1", DataType.Int32);
-			Assert.IsNotNull(a1);
+        var a1 = new Attribute(context, "a1", DataType.Int32);
+        Assert.IsNotNull(a1);
 
-			array_schema.AddAttributes(a1);
+        array_schema.AddAttributes(a1);
 
-			array_schema.SetDomain(domain);
+        array_schema.SetDomain(domain);
 
-			array_schema.SetCellOrder(LayoutType.Hilbert);
-			array_schema.SetCapacity(2);
-			array_schema.Check();
-		}
+        array_schema.SetCellOrder(LayoutType.Hilbert);
+        array_schema.SetCapacity(2);
+        array_schema.Check();
+    }
 
-		[TestMethod]
-		public void TestArraySchemaInt32DenseHilbert()
-		{
-			var config = new Config();
-			var context = new Context(config);
+    [TestMethod]
+    public void TestArraySchemaInt32DenseHilbert()
+    {
+        var config = new Config();
+        var context = new Context(config);
 
-			var d1 = Dimension.Create(context, "d1", 0, 100, 5);
-			Assert.IsNotNull(d1);
+        var d1 = Dimension.Create(context, "d1", 0, 100, 5);
+        Assert.IsNotNull(d1);
 
-			var d2 = Dimension.Create(context, "d2", 0, 200, 5);
-			Assert.IsNotNull(d1);
+        var d2 = Dimension.Create(context, "d2", 0, 200, 5);
+        Assert.IsNotNull(d1);
 
-			var domain = new Domain(context);
-			Assert.IsNotNull(domain);
+        var domain = new Domain(context);
+        Assert.IsNotNull(domain);
 
-			domain.AddDimensions(d1, d2);
+        domain.AddDimensions(d1, d2);
 
-			var array_schema = new ArraySchema(context, ArrayType.Dense);
-			Assert.IsNotNull(array_schema);
+        var array_schema = new ArraySchema(context, ArrayType.Dense);
+        Assert.IsNotNull(array_schema);
 
-			var a1 = new Attribute(context, "a1", DataType.Int32);
-			Assert.IsNotNull(a1);
+        var a1 = new Attribute(context, "a1", DataType.Int32);
+        Assert.IsNotNull(a1);
 
-			array_schema.AddAttributes(a1);
+        array_schema.AddAttributes(a1);
 
-			array_schema.SetDomain(domain);
+        array_schema.SetDomain(domain);
 
-			
-			Assert.ThrowsException<TileDBException>(()=>array_schema.SetCellOrder(LayoutType.Hilbert));
-			Assert.ThrowsException<TileDBException>(()=>array_schema.SetTileOrder(LayoutType.Hilbert));
-			array_schema.SetCapacity(2);
-			array_schema.Check();
-		}
 
-		[TestMethod]
-		public void TestArraySchemaInt32NegativeDomainHilbert()
-		{
-			var config = new Config();
-			var context = new Context(config);
+        Assert.ThrowsException<TileDBException>(() => array_schema.SetCellOrder(LayoutType.Hilbert));
+        Assert.ThrowsException<TileDBException>(() => array_schema.SetTileOrder(LayoutType.Hilbert));
+        array_schema.SetCapacity(2);
+        array_schema.Check();
+    }
 
-			var d1 = Dimension.Create(context, "d1", -50, 50, 5);
-			Assert.IsNotNull(d1);
+    [TestMethod]
+    public void TestArraySchemaInt32NegativeDomainHilbert()
+    {
+        var config = new Config();
+        var context = new Context(config);
+
+        var d1 = Dimension.Create(context, "d1", -50, 50, 5);
+        Assert.IsNotNull(d1);
+
+        var d2 = Dimension.Create(context, "d2", -100, 100, 5);
+        Assert.IsNotNull(d1);
+
+        var domain = new Domain(context);
+        Assert.IsNotNull(domain);
 
-			var d2 = Dimension.Create(context, "d2", -100, 100, 5);
-			Assert.IsNotNull(d1);
+        domain.AddDimensions(d1, d2);
 
-			var domain = new Domain(context);
-			Assert.IsNotNull(domain);
+        var array_schema = new ArraySchema(context, ArrayType.Sparse);
+        Assert.IsNotNull(array_schema);
 
-			domain.AddDimensions(d1, d2);
+        var a1 = new Attribute(context, "a1", DataType.Int32);
+        Assert.IsNotNull(a1);
 
-			var array_schema = new ArraySchema(context, ArrayType.Sparse);
-			Assert.IsNotNull(array_schema);
+        array_schema.AddAttributes(a1);
 
-			var a1 = new Attribute(context, "a1", DataType.Int32);
-			Assert.IsNotNull(a1);
+        array_schema.SetDomain(domain);
 
-			array_schema.AddAttributes(a1);
+        array_schema.SetCellOrder(LayoutType.Hilbert);
+        array_schema.SetCapacity(2);
+        array_schema.Check();
+    }
+
+    [TestMethod]
+    public void TestArraySchemaFloat32Hilbert()
+    {
+        var config = new Config();
+        var context = new Context(config);
 
-			array_schema.SetDomain(domain);
+        var d1 = Dimension.Create(context, "d1", 0.0f, 1.0f, 0.01f);
+        Assert.IsNotNull(d1);
 
-			array_schema.SetCellOrder(LayoutType.Hilbert);
-			array_schema.SetCapacity(2);
-			array_schema.Check();
-		}
+        var d2 = Dimension.Create(context, "d2", 0.0f, 2.0f, 0.01f);
+        Assert.IsNotNull(d1);
 
-		[TestMethod]
-		public void TestArraySchemaFloat32Hilbert()
-		{
-			var config = new Config();
-			var context = new Context(config);
+        var domain = new Domain(context);
+        Assert.IsNotNull(domain);
 
-			var d1 = Dimension.Create(context, "d1", 0.0f, 1.0f, 0.01f);
-			Assert.IsNotNull(d1);
+        domain.AddDimensions(d1, d2);
 
-			var d2 = Dimension.Create(context, "d2", 0.0f, 2.0f, 0.01f);
-			Assert.IsNotNull(d1);
+        var array_schema = new ArraySchema(context, ArrayType.Sparse);
+        Assert.IsNotNull(array_schema);
 
-			var domain = new Domain(context);
-			Assert.IsNotNull(domain);
+        var a1 = new Attribute(context, "a1", DataType.Int32);
+        Assert.IsNotNull(a1);
 
-			domain.AddDimensions(d1, d2);
+        array_schema.AddAttributes(a1);
 
-			var array_schema = new ArraySchema(context, ArrayType.Sparse);
-			Assert.IsNotNull(array_schema);
-
-			var a1 = new Attribute(context, "a1", DataType.Int32);
-			Assert.IsNotNull(a1);
-
-			array_schema.AddAttributes(a1);
-
-			array_schema.SetDomain(domain);
-
-			array_schema.SetCellOrder(LayoutType.Hilbert);
-			array_schema.SetCapacity(2);
-			array_schema.Check();
-		}
-
-		[TestMethod]
-		public void TestArraySchemaStringHilbert()
-		{
-			var config = new Config();
-			var context = new Context(config);
-			
-			var d1 = Dimension.CreateString(context, "d1");
-			Assert.IsNotNull(d1);
-			
-			var d2 = Dimension.CreateString(context, "d2");
-			Assert.IsNotNull(d1);
-			
-			var domain = new Domain(context);
-			Assert.IsNotNull(domain);
-			
-			domain.AddDimensions(d1, d2);
-			
-			var array_schema = new ArraySchema(context, ArrayType.Sparse);
-			Assert.IsNotNull(array_schema);
-			
-			var a1 = new Attribute(context, "a1", DataType.Int32);
-			Assert.IsNotNull(a1);
-			
-			array_schema.AddAttributes(a1);
-			
-			array_schema.SetDomain(domain);
-			
-			array_schema.SetCellOrder(LayoutType.Hilbert);
-			array_schema.SetCapacity(2);
-			array_schema.Check();			
-		}
-	}
+        array_schema.SetDomain(domain);
+
+        array_schema.SetCellOrder(LayoutType.Hilbert);
+        array_schema.SetCapacity(2);
+        array_schema.Check();
+    }
+
+    [TestMethod]
+    public void TestArraySchemaStringHilbert()
+    {
+        var config = new Config();
+        var context = new Context(config);
+
+        var d1 = Dimension.CreateString(context, "d1");
+        Assert.IsNotNull(d1);
+
+        var d2 = Dimension.CreateString(context, "d2");
+        Assert.IsNotNull(d1);
+
+        var domain = new Domain(context);
+        Assert.IsNotNull(domain);
+
+        domain.AddDimensions(d1, d2);
+
+        var array_schema = new ArraySchema(context, ArrayType.Sparse);
+        Assert.IsNotNull(array_schema);
+
+        var a1 = new Attribute(context, "a1", DataType.Int32);
+        Assert.IsNotNull(a1);
+
+        array_schema.AddAttributes(a1);
+
+        array_schema.SetDomain(domain);
+
+        array_schema.SetCellOrder(LayoutType.Hilbert);
+        array_schema.SetCapacity(2);
+        array_schema.Check();
+    }
+}
diff --git a/tests/TileDB.CSharp.Test/AttributeTest.cs b/tests/TileDB.CSharp.Test/AttributeTest.cs
index 00eb1be0..e2e5b610 100644
--- a/tests/TileDB.CSharp.Test/AttributeTest.cs
+++ b/tests/TileDB.CSharp.Test/AttributeTest.cs
@@ -1,4 +1,5 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
 using System.IO;
 
 namespace TileDB.CSharp.Test;
@@ -52,6 +53,9 @@ public void TestFullAttribute()
         attribute.SetFillValue(12);
         var value_size = attribute.FillValue<int>();
         Assert.AreEqual(12, value_size[0]);
+
+        var dump = attribute.ToString();
+        Assert.IsTrue(dump.Contains(nameof(FilterType.Gzip), StringComparison.OrdinalIgnoreCase));
     }
 
     [TestMethod]
diff --git a/tests/TileDB.CSharp.Test/DimensionTest.cs b/tests/TileDB.CSharp.Test/DimensionTest.cs
index ec9b5f5e..82b95244 100644
--- a/tests/TileDB.CSharp.Test/DimensionTest.cs
+++ b/tests/TileDB.CSharp.Test/DimensionTest.cs
@@ -1,4 +1,5 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
 
 namespace TileDB.CSharp.Test;
 
@@ -17,6 +18,9 @@ public void TestDimension() {
         Assert.AreEqual(extent, dimension.TileExtent<int>());
         var dim_domain = dimension.GetDomain<int>();
         Assert.AreEqual((1, 10), dim_domain);
+
+        var dump = dimension.ToString();
+        Assert.IsTrue(dump.Contains("test", StringComparison.Ordinal));
     }
 
     [TestMethod]
diff --git a/tests/TileDB.CSharp.Test/DomainTest.cs b/tests/TileDB.CSharp.Test/DomainTest.cs
index 40798638..8d662383 100644
--- a/tests/TileDB.CSharp.Test/DomainTest.cs
+++ b/tests/TileDB.CSharp.Test/DomainTest.cs
@@ -44,5 +44,8 @@ public void TestDomain() {
         dim2 = domain.Dimension("testint");
         Assert.AreEqual(DataType.Int32, dim2.Type());
         Assert.AreEqual("testint", dim2.Name());
+
+        var dump = domain.ToString();
+        Assert.IsTrue(dump.Contains("testuint", StringComparison.Ordinal));
     }
 }
diff --git a/tests/TileDB.CSharp.Test/EnumerationTest.cs b/tests/TileDB.CSharp.Test/EnumerationTest.cs
index baec7927..c6a674b9 100644
--- a/tests/TileDB.CSharp.Test/EnumerationTest.cs
+++ b/tests/TileDB.CSharp.Test/EnumerationTest.cs
@@ -47,6 +47,9 @@ public void TestFixedSize(uint cellValNum)
         CollectionAssert.AreEqual(expectedValues, values);
         CollectionAssert.AreEqual(new byte[] { 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0 }, rawData);
         Assert.AreEqual(0, rawOffsets.Length);
+
+        var dump = e.ToString();
+        Assert.IsTrue(dump.Contains("test_fixed", StringComparison.Ordinal));
     }
 
     [TestMethod]