RDFGraph and RDFMemoryStore are now compaitble with IAsyncDisposable

Author: Marco De Salvo

RDFSharp.Test/Model/RDFGraphTest.cs

@@ -1818,6 +1818,21 @@ public async Task ShouldEnumerateGraphAsync()
         Assert.AreEqual(2, z);
     }
 
+    [TestMethod]
+    public async Task ShouldDisposeGraphWithUsingAsync()
+    {
+        RDFGraph graph;
+        await using (graph = new RDFGraph([
+                   new RDFTriple(new RDFResource("http://subj/"),new RDFResource("http://pred/"),new RDFResource("http://obj/")),
+                   new RDFTriple(new RDFResource("http://subj/"),new RDFResource("http://pred/"),new RDFPlainLiteral("lit")) ]))
+        {
+            Assert.IsFalse(graph.Disposed);
+            Assert.IsNotNull(graph.Index);
+        }
+        Assert.IsTrue(graph.Disposed);
+        Assert.IsNull(graph.Index);
+    }
+
     [TestMethod]
     public async Task ShouldAddContainerAsync()
     {

RDFSharp.Test/Store/Engines/RDFMemoryStoreTest.cs

@@ -1863,6 +1863,20 @@ public async Task ShouldEnumerateQuadruplesAsync()
         Assert.AreEqual(2, z);
     }
 
+    [TestMethod]
+    public async Task ShouldDisposeMemoryStoreWithUsingAsync()
+    {
+        RDFMemoryStore store;
+        await using (store = new RDFMemoryStore([
+                   new RDFQuadruple(new RDFContext("ex:c"), new RDFResource("ex:s"), new RDFResource("ex:p"), new RDFResource("ex:o")) ]))
+        {
+            Assert.IsFalse(store.Disposed);
+            Assert.IsNotNull(store.Index);
+        }
+        Assert.IsTrue(store.Disposed);
+        Assert.IsNull(store.Index);
+    }
+
     [TestMethod]
     public async Task ShouldMergeGraphAsync()
     {

RDFSharp/Model/RDFGraph.cs

@@ -35,7 +35,7 @@ namespace RDFSharp.Model
     /// RDFGraph represents an Uri-named collection of triples
     /// </summary>
 #if NET8_0_OR_GREATER
-    public sealed class RDFGraph : RDFDataSource, IEquatable<RDFGraph>, IEnumerable<RDFTriple>, IAsyncEnumerable<RDFTriple>, IDisposable
+    public sealed class RDFGraph : RDFDataSource, IEquatable<RDFGraph>, IEnumerable<RDFTriple>, IAsyncEnumerable<RDFTriple>, IDisposable, IAsyncDisposable
 #else
     public sealed class RDFGraph : RDFDataSource, IEquatable<RDFGraph>, IEnumerable<RDFTriple>, IDisposable
 #endif
@@ -179,6 +179,18 @@ public void Dispose()
             GC.SuppressFinalize(this);
         }
 
+#if NET8_0_OR_GREATER
+        /// <summary>
+        /// Asynchronously disposes the graph (IAsyncDisposable)
+        /// </summary>
+        ValueTask IAsyncDisposable.DisposeAsync()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+            return ValueTask.CompletedTask;
+        }
+#endif
+
         /// <summary>
         /// Disposes the graph
         /// </summary>

RDFSharp/Store/Engines/RDFMemoryStore.cs

@@ -23,18 +23,20 @@ limitations under the License.
 using System.IO;
 using System.Linq;
 using System.Net;
-using System.Runtime.CompilerServices;
 using System.Text;
-using System.Threading;
 using System.Threading.Tasks;
+#if NET8_0_OR_GREATER
+using System.Runtime.CompilerServices;
+using System.Threading;
+#endif
 
 namespace RDFSharp.Store
 {
     /// <summary>
     /// RDFMemoryStore represents an in-memory RDF store engine.
     /// </summary>
 #if NET8_0_OR_GREATER
-    public sealed class RDFMemoryStore : RDFStore, IEnumerable<RDFQuadruple>, IAsyncEnumerable<RDFQuadruple>, IDisposable
+    public sealed class RDFMemoryStore : RDFStore, IEnumerable<RDFQuadruple>, IAsyncEnumerable<RDFQuadruple>, IDisposable, IAsyncDisposable
 #else
     public sealed class RDFMemoryStore : RDFStore, IEnumerable<RDFQuadruple>, IDisposable
 #endif
@@ -170,14 +172,26 @@ public IAsyncEnumerator<RDFQuadruple> GetAsyncEnumerator(CancellationToken cance
 #endif
 
         /// <summary>
-        /// Disposes the memory store (IDisposable)
+        /// Disposes the store (IDisposable)
         /// </summary>
         public void Dispose()
         {
             Dispose(true);
             GC.SuppressFinalize(this);
         }
 
+#if NET8_0_OR_GREATER
+        /// <summary>
+        /// Asynchronously disposes the store (IAsyncDisposable)
+        /// </summary>
+        ValueTask IAsyncDisposable.DisposeAsync()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+            return ValueTask.CompletedTask;
+        }
+#endif
+
         /// <summary>
         /// Disposes the memory store
         /// </summary>

RDFSharp/Store/RDFStore.cs

@@ -21,7 +21,6 @@ limitations under the License.
 using System.Linq;
 using System.Threading.Tasks;
 using RDFSharp.Model;
-using RDFSharp.Query;
 
 namespace RDFSharp.Store
 {