Moved MemoryStream to an instance variable

Author: edwardneal

src/Microsoft.Data.SqlClient/tests/UnitTests/Microsoft/Data/SqlClient/UdtSerialization/InvalidSerializationTest.cs

@@ -14,18 +14,31 @@ namespace Microsoft.Data.SqlClient.UnitTests.UdtSerialization;
 /// <summary>
 /// Attempts to serialize types which do not meet the requirements for either user-defined or native serialization.
 /// </summary>
-public class InvalidSerializationTest
+public sealed class InvalidSerializationTest : IDisposable
 {
+    private readonly MemoryStream _stream;
+
+    /// <summary>
+    /// Initializes the MemoryStream used for all tests in this class.
+    /// </summary>
+    public InvalidSerializationTest()
+    {
+        _stream = new MemoryStream();
+    }
+
+    void IDisposable.Dispose()
+    {
+        _stream.Dispose();
+    }
+
     /// <summary>
     /// Attempts to serialize a class that does not have the SqlUserDefinedType attribute. Verifies that this fails.
     /// </summary>
     [Fact]
     public void RequiresSqlUserDefinedTypeAttribute()
     {
-        using MemoryStream stream = new();
-
         var exception = Assert.Throws<InvalidUdtException>(
-            () => SerializationHelperSql9.Serialize(stream, new ClassMissingSqlUserDefinedTypeAttribute()));
+            () => SerializationHelperSql9.Serialize(_stream, new ClassMissingSqlUserDefinedTypeAttribute()));
 
         Assert.Equal($"'{typeof(ClassMissingSqlUserDefinedTypeAttribute).FullName}' is an invalid user defined type, reason: no UDT attribute.", exception.Message);
     }
@@ -37,10 +50,8 @@ public void RequiresSqlUserDefinedTypeAttribute()
     [Fact]
     public void CannotSerializeUnknownFormattedType()
     {
-        using MemoryStream stream = new();
-
         var exception = Assert.Throws<ArgumentOutOfRangeException>("Format",
-            () => SerializationHelperSql9.Serialize(stream, new UnknownFormattedClass()));
+            () => SerializationHelperSql9.Serialize(_stream, new UnknownFormattedClass()));
 
 #if NET
         Assert.Equal("The Format enumeration value, 0, is not supported by the format method. (Parameter 'Format')", exception.Message);

src/Microsoft.Data.SqlClient/tests/UnitTests/Microsoft/Data/SqlClient/UdtSerialization/NativeSerializationTest.cs

@@ -16,8 +16,23 @@ namespace Microsoft.Data.SqlClient.UnitTests.UdtSerialization;
 /// Tests the serialization method defined by MS-SSCLRT. Ensures that combinations of primitives and custom types round-trip.
 /// </summary>
 /// <seealso href="https://learn.microsoft.com/en-us/openspecs/sql_server_protocols/ms-ssclrt/77460aa9-8c2f-4449-a65e-1d649ebd77fa"/>
-public class NativeSerializationTest
+public sealed class NativeSerializationTest : IDisposable
 {
+    private readonly MemoryStream _stream;
+
+    /// <summary>
+    /// Initializes the MemoryStream used for all tests in this class.
+    /// </summary>
+    public NativeSerializationTest()
+    {
+        _stream = new MemoryStream();
+    }
+
+    void IDisposable.Dispose()
+    {
+        _stream.Dispose();
+    }
+
     /// <summary>
     /// Provides a collection of test data representing non-null primitive type values and their corresponding
     /// serialized byte arrays.
@@ -206,9 +221,8 @@ public void CanSerializeTopLevelClass()
             Field1 = true,
             Field2 = new BoolWrapperStruct() { Field1 = true }
         };
-        using MemoryStream stream = new();
 
-        SerializationHelperSql9.Serialize(stream, validWrapper);
+        SerializationHelperSql9.Serialize(_stream, validWrapper);
     }
 
     /// <summary>
@@ -224,9 +238,8 @@ public void CannotSerializeNestedClass()
             Field1 = true,
             Field2 = new BoolWrapperClass() { Field1 = true }
         };
-        using MemoryStream stream = new();
 
-        var ex = Assert.Throws<Exception>(() => SerializationHelperSql9.Serialize(stream, invalidWrapper));
+        var ex = Assert.Throws<Exception>(() => SerializationHelperSql9.Serialize(_stream, invalidWrapper));
         string expectedException = StringsHelper.GetString(Strings.SQL_CannotCreateNormalizer, invalidWrapper.Field2.GetType().FullName);
 
         Assert.Equal(expectedException, ex.Message);
@@ -244,9 +257,8 @@ public void CannotSerializeNonPrimitiveType()
             Field1 = 1,
             Field2 = IntPtr.Zero
         };
-        using MemoryStream stream = new();
 
-        var ex = Assert.Throws<Exception>(() => SerializationHelperSql9.Serialize(stream, invalidWrapper));
+        var ex = Assert.Throws<Exception>(() => SerializationHelperSql9.Serialize(_stream, invalidWrapper));
         string expectedException = StringsHelper.GetString(Strings.SQL_CannotCreateNormalizer, invalidWrapper.Field2.GetType().FullName);
 
         Assert.Equal(expectedException, ex.Message);
@@ -257,23 +269,22 @@ public void CannotSerializeNonPrimitiveType()
     /// </summary>
     /// <param name="inputValue">Object to serialize.</param>
     /// <param name="expectedValue">Expected serialization output.</param>
-    private static void RoundtripType(object inputValue, byte[] expectedValue)
+    private void RoundtripType(object inputValue, byte[] expectedValue)
     {
-        using MemoryStream stream = new();
         int typeSize = SerializationHelperSql9.SizeInBytes(inputValue.GetType());
         int objectSize = SerializationHelperSql9.SizeInBytes(inputValue);
         int maxTypeSize = SerializationHelperSql9.GetUdtMaxLength(inputValue.GetType());
 
-        SerializationHelperSql9.Serialize(stream, inputValue);
-        stream.Seek(0, SeekOrigin.Begin);
-        object readPrimitive = SerializationHelperSql9.Deserialize(stream, inputValue.GetType());
+        SerializationHelperSql9.Serialize(_stream, inputValue);
+        _stream.Seek(0, SeekOrigin.Begin);
+        object readPrimitive = SerializationHelperSql9.Deserialize(_stream, inputValue.GetType());
 
         // For native formatting, the type size, the object size and the maximum object size will always be identical
         Assert.Equal(typeSize, objectSize);
         Assert.Equal(expectedValue.Length, typeSize);
         Assert.Equal(typeSize, maxTypeSize);
 
-        Assert.Equal(expectedValue, stream.ToArray());
+        Assert.Equal(expectedValue, _stream.ToArray());
         Assert.Equal(inputValue, readPrimitive);
     }
 }

src/Microsoft.Data.SqlClient/tests/UnitTests/Microsoft/Data/SqlClient/UdtSerialization/UserDefinedSerializationTest.cs

@@ -14,8 +14,23 @@ namespace Microsoft.Data.SqlClient.UnitTests.UdtSerialization;
 /// <summary>
 /// Tests the user-defined UDT serialization method. Verifies that custom types round-trip.
 /// </summary>
-public class UserDefinedSerializationTest
+public sealed class UserDefinedSerializationTest : IDisposable
 {
+    private readonly MemoryStream _stream;
+
+    /// <summary>
+    /// Initializes the MemoryStream used for all tests in this class.
+    /// </summary>
+    public UserDefinedSerializationTest()
+    {
+        _stream = new MemoryStream();
+    }
+
+    void IDisposable.Dispose()
+    {
+        _stream.Dispose();
+    }
+
     /// <summary>
     /// Attempts to serialize and deserialize an instance of a struct with a user-defined serialization method.
     /// </summary>
@@ -39,13 +54,11 @@ public void CanSerializeClass()
     [Fact]
     public void RequiresPublicParameterlessConstructor()
     {
-        using MemoryStream stream = new();
-
-        SerializationHelperSql9.Serialize(stream, new UserDefinedMissingPublicConstructor(true));
-        stream.Seek(0, SeekOrigin.Begin);
+        SerializationHelperSql9.Serialize(_stream, new UserDefinedMissingPublicConstructor(true));
+        _stream.Seek(0, SeekOrigin.Begin);
 
         Assert.Throws<MissingMethodException>(
-            () => SerializationHelperSql9.Deserialize(stream, typeof(UserDefinedMissingPublicConstructor)));
+            () => SerializationHelperSql9.Deserialize(_stream, typeof(UserDefinedMissingPublicConstructor)));
     }
 
     /// <summary>
@@ -55,24 +68,21 @@ public void RequiresPublicParameterlessConstructor()
     [Fact]
     public void RequiresIBinarySerializeImplementation()
     {
-        using MemoryStream stream = new();
-
         Assert.Throws<InvalidCastException>(
-            () => SerializationHelperSql9.Serialize(stream, new UserDefinedDoesNotImplementIBinarySerialize()));
+            () => SerializationHelperSql9.Serialize(_stream, new UserDefinedDoesNotImplementIBinarySerialize()));
     }
 
-    private static void RoundtripType<T>(T userObject)
+    private void RoundtripType<T>(T userObject)
         where T : IFormattingProgress
     {
-        using MemoryStream stream = new();
         int typeSize = SerializationHelperSql9.SizeInBytes(userObject.GetType());
         int objectSize = SerializationHelperSql9.SizeInBytes(userObject);
         int maxTypeSize = SerializationHelperSql9.GetUdtMaxLength(userObject.GetType());
 
-        SerializationHelperSql9.Serialize(stream, userObject);
-        stream.Seek(0, SeekOrigin.Begin);
-        byte[] serializedValue = stream.ToArray();
-        T readInstance = (T)SerializationHelperSql9.Deserialize(stream, userObject.GetType());
+        SerializationHelperSql9.Serialize(_stream, userObject);
+        _stream.Seek(0, SeekOrigin.Begin);
+        byte[] serializedValue = _stream.ToArray();
+        T readInstance = (T)SerializationHelperSql9.Deserialize(_stream, userObject.GetType());
 
         // If this is a struct, it will have been copied by value and the write to WriteInvoked will have been made
         // to another copy of our object