Prevent disposing of enumerators returned by Statement.Query from disposing the underlying Statement.

Author: bordoley

SQLitePCL.pretty.tests/ImplementationTests.cs

@@ -357,12 +357,18 @@ public void TestQuery()
                 using (var stmt = db.PrepareStatement("SELECT * from FOO WHERE v < ?"))
                 {
                     var result = stmt.Query(50).Count();
+
+                    // Ensure that enumerating the Query Enumerable doesn't dispose the stmt
+                    Assert.DoesNotThrow(() => { var x = stmt.IsBusy; });
                     Assert.AreEqual(result, 50);
                 }
 
                 using (var stmt = db.PrepareStatement("SELECT * from FOO WHERE v < 50"))
                 {
                     var result = stmt.Query().Count();
+
+                    // Ensure that enumerating the Query Enumerable doesn't dispose the stmt
+                    Assert.DoesNotThrow(() => { var x = stmt.IsBusy; });
                     Assert.AreEqual(result, 50);
                 }
             }

SQLitePCL.pretty/Statement.cs

@@ -16,6 +16,7 @@ limitations under the License.
 */
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics.Contracts;
 using System.IO;
@@ -111,7 +112,9 @@ public static IEnumerable<IReadOnlyList<IResultSetValue>> Query(
                     This.Reset();
                     This.ClearBindings();
                     This.Bind(values);
-                    return This;
+
+                    // Prevent the statement from being disposed when the enumerator is disposed
+                    return new NonDisposingEnumerator<IReadOnlyList<IResultSetValue>>(This);
                 });
         }
 
@@ -127,8 +130,52 @@ public static IEnumerable<IReadOnlyList<IResultSetValue>> Query(this IStatement
             return new DelegatingEnumerable<IReadOnlyList<IResultSetValue>>(() => 
                 {
                     This.Reset();
-                    return This;
+
+                    // Prevent the statement from being disposed when the enumerator is disposed
+                    return new NonDisposingEnumerator<IReadOnlyList<IResultSetValue>>(This);
                 });
         }
     }
+
+    // An IEnumerator that wraps a delegate, and prevents unintentional disposing of the delegate
+    internal sealed class NonDisposingEnumerator<T> : IEnumerator<T>
+    {
+        private readonly IEnumerator<T> deleg;
+
+        internal NonDisposingEnumerator(IEnumerator<T> deleg)
+        {
+            this.deleg = deleg;
+        }
+
+        public void Dispose()
+        {
+            // Intentionally left blank
+        }
+
+        public bool MoveNext()
+        {
+            return deleg.MoveNext();
+        }
+
+        public void Reset()
+        {
+            deleg.Reset();
+        }
+
+        object IEnumerator.Current
+        {
+            get
+            {
+                return deleg.Current;
+            }
+        }
+
+        public T Current
+        {
+            get
+            {
+                return deleg.Current;
+            }
+        }
+    }
 }