diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/DateTimeVariantTest.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/DateTimeVariantTest.cs
index 8f6965d043..8e5b41db98 100644
--- a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/DateTimeVariantTest.cs
+++ b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/DateTimeVariantTest.cs
@@ -78,25 +78,20 @@ private static void TestSimpleParameter_Type(object paramValue, string expectedT
             string procName = DataTestUtility.GetUniqueNameForSqlServer("paramProc1");
             try
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropStoredProcedure(conn, procName);
+                xsql(conn, string.Format("create proc {0} (@param {1}) as begin select @param end;", procName, expectedBaseTypeName));
+
+                using SqlCommand cmd = conn.CreateCommand();
+                cmd.CommandText = procName;
+                cmd.CommandType = CommandType.StoredProcedure;
+                SqlParameter p = cmd.Parameters.AddWithValue("@param", paramValue);
+                cmd.Parameters[0].SqlDbType = GetSqlDbType(expectedBaseTypeName);
+                using (SqlDataReader dr = cmd.ExecuteReader())
                 {
-                    conn.Open();
-                    DropStoredProcedure(conn, procName);
-                    xsql(conn, string.Format("create proc {0} (@param {1}) as begin select @param end;", procName, expectedBaseTypeName));
-
-                    using (SqlCommand cmd = conn.CreateCommand())
-                    {
-                        cmd.CommandText = procName;
-                        cmd.CommandType = CommandType.StoredProcedure;
-                        SqlParameter p = cmd.Parameters.AddWithValue("@param", paramValue);
-                        cmd.Parameters[0].SqlDbType = GetSqlDbType(expectedBaseTypeName);
-                        using (SqlDataReader dr = cmd.ExecuteReader())
-                        {
-                            dr.Read();
-                            VerifyReaderTypeAndValue("Test Simple Parameter [Data Type]", expectedBaseTypeName, expectedTypeName, dr[0], expectedTypeName, paramValue);
-                            dr.Dispose();
-                        }
-                    }
+                    dr.Read();
+                    VerifyReaderTypeAndValue("Test Simple Parameter [Data Type]", expectedBaseTypeName, expectedTypeName, dr[0], expectedTypeName, paramValue);
                 }
             }
             catch (Exception e)
@@ -108,11 +103,9 @@ private static void TestSimpleParameter_Type(object paramValue, string expectedT
             }
             finally
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
-                {
-                    conn.Open();
-                    DropStoredProcedure(conn, procName);
-                }
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropStoredProcedure(conn, procName);
             }
         }
 
@@ -125,25 +118,20 @@ private static void TestSimpleParameter_Variant(object paramValue, string expect
             string procName = DataTestUtility.GetUniqueNameForSqlServer("paramProc2");
             try
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropStoredProcedure(conn, procName);
+                xsql(conn, string.Format("create proc {0} (@param sql_variant) as begin select @param, sql_variant_property(@param,'BaseType') as BaseType end;", procName));
+
+                using SqlCommand cmd = conn.CreateCommand();
+                cmd.CommandText = procName;
+                cmd.CommandType = CommandType.StoredProcedure;
+                SqlParameter p = cmd.Parameters.AddWithValue("@param", paramValue);
+                cmd.Parameters[0].SqlDbType = SqlDbType.Variant;
+                using (SqlDataReader dr = cmd.ExecuteReader())
                 {
-                    conn.Open();
-                    DropStoredProcedure(conn, procName);
-                    xsql(conn, string.Format("create proc {0} (@param sql_variant) as begin select @param, sql_variant_property(@param,'BaseType') as BaseType end;", procName));
-
-                    using (SqlCommand cmd = conn.CreateCommand())
-                    {
-                        cmd.CommandText = procName;
-                        cmd.CommandType = CommandType.StoredProcedure;
-                        SqlParameter p = cmd.Parameters.AddWithValue("@param", paramValue);
-                        cmd.Parameters[0].SqlDbType = SqlDbType.Variant;
-                        using (SqlDataReader dr = cmd.ExecuteReader())
-                        {
-                            dr.Read();
-                            VerifyReaderTypeAndValue("Test Simple Parameter [Variant Type]", "SqlDbType.Variant", dr, expectedTypeName, expectedBaseTypeName, paramValue);
-                            dr.Dispose();
-                        }
-                    }
+                    dr.Read();
+                    VerifyReaderTypeAndValue("Test Simple Parameter [Variant Type]", "SqlDbType.Variant", dr, expectedTypeName, expectedBaseTypeName, paramValue);
                 }
             }
             catch (Exception e)
@@ -155,11 +143,9 @@ private static void TestSimpleParameter_Variant(object paramValue, string expect
             }
             finally
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
-                {
-                    conn.Open();
-                    DropStoredProcedure(conn, procName);
-                }
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropStoredProcedure(conn, procName);
             }
         }
 
@@ -170,32 +156,27 @@ private static void TestSqlDataRecordParameterToTVP_Type(object paramValue, stri
             string tvpTypeName = DataTestUtility.GetUniqueNameForSqlServer("tvpType");
             try
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropType(conn, tvpTypeName);
+                xsql(conn, string.Format("create type dbo.{0} as table (f1 {1})", tvpTypeName, expectedBaseTypeName));
+
+                // Send TVP using SqlMetaData.
+                SqlMetaData[] metadata = new SqlMetaData[1];
+                metadata[0] = new SqlMetaData("f1", GetSqlDbType(expectedBaseTypeName));
+                SqlDataRecord[] record = new SqlDataRecord[1];
+                record[0] = new SqlDataRecord(metadata);
+                record[0].SetValue(0, paramValue);
+
+                using SqlCommand cmd = conn.CreateCommand();
+                cmd.CommandText = "select f1 from @tvpParam";
+                SqlParameter p = cmd.Parameters.AddWithValue("@tvpParam", record);
+                p.SqlDbType = SqlDbType.Structured;
+                p.TypeName = string.Format("dbo.{0}", tvpTypeName);
+                using (SqlDataReader dr = cmd.ExecuteReader())
                 {
-                    conn.Open();
-                    DropType(conn, tvpTypeName);
-                    xsql(conn, string.Format("create type dbo.{0} as table (f1 {1})", tvpTypeName, expectedBaseTypeName));
-
-                    // Send TVP using SqlMetaData.
-                    SqlMetaData[] metadata = new SqlMetaData[1];
-                    metadata[0] = new SqlMetaData("f1", GetSqlDbType(expectedBaseTypeName));
-                    SqlDataRecord[] record = new SqlDataRecord[1];
-                    record[0] = new SqlDataRecord(metadata);
-                    record[0].SetValue(0, paramValue);
-
-                    using (SqlCommand cmd = conn.CreateCommand())
-                    {
-                        cmd.CommandText = "select f1 from @tvpParam";
-                        SqlParameter p = cmd.Parameters.AddWithValue("@tvpParam", record);
-                        p.SqlDbType = SqlDbType.Structured;
-                        p.TypeName = string.Format("dbo.{0}", tvpTypeName);
-                        using (SqlDataReader dr = cmd.ExecuteReader())
-                        {
-                            dr.Read();
-                            VerifyReaderTypeAndValue("Test SqlDataRecord Parameter To TVP [Data Type]", expectedBaseTypeName, expectedTypeName, dr[0], expectedTypeName, paramValue);
-                            dr.Dispose();
-                        }
-                    }
+                    dr.Read();
+                    VerifyReaderTypeAndValue("Test SqlDataRecord Parameter To TVP [Data Type]", expectedBaseTypeName, expectedTypeName, dr[0], expectedTypeName, paramValue);
                 }
             }
             catch (Exception e)
@@ -207,11 +188,9 @@ private static void TestSqlDataRecordParameterToTVP_Type(object paramValue, stri
             }
             finally
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
-                {
-                    conn.Open();
-                    DropType(conn, tvpTypeName);
-                }
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropType(conn, tvpTypeName);
             }
         }
 
@@ -224,32 +203,27 @@ private static void TestSqlDataRecordParameterToTVP_Variant(object paramValue, s
             string tvpTypeName = DataTestUtility.GetUniqueNameForSqlServer("tvpVariant");
             try
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropType(conn, tvpTypeName);
+                xsql(conn, string.Format("create type dbo.{0} as table (f1 sql_variant)", tvpTypeName));
+
+                // Send TVP using SqlMetaData.
+                SqlMetaData[] metadata = new SqlMetaData[1];
+                metadata[0] = new SqlMetaData("f1", SqlDbType.Variant);
+                SqlDataRecord[] record = new SqlDataRecord[1];
+                record[0] = new SqlDataRecord(metadata);
+                record[0].SetValue(0, paramValue);
+
+                using SqlCommand cmd = conn.CreateCommand();
+                cmd.CommandText = "select f1, sql_variant_property(f1,'BaseType') as BaseType from @tvpParam";
+                SqlParameter p = cmd.Parameters.AddWithValue("@tvpParam", record);
+                p.SqlDbType = SqlDbType.Structured;
+                p.TypeName = string.Format("dbo.{0}", tvpTypeName);
+                using (SqlDataReader dr = cmd.ExecuteReader())
                 {
-                    conn.Open();
-                    DropType(conn, tvpTypeName);
-                    xsql(conn, string.Format("create type dbo.{0} as table (f1 sql_variant)", tvpTypeName));
-
-                    // Send TVP using SqlMetaData.
-                    SqlMetaData[] metadata = new SqlMetaData[1];
-                    metadata[0] = new SqlMetaData("f1", SqlDbType.Variant);
-                    SqlDataRecord[] record = new SqlDataRecord[1];
-                    record[0] = new SqlDataRecord(metadata);
-                    record[0].SetValue(0, paramValue);
-
-                    using (SqlCommand cmd = conn.CreateCommand())
-                    {
-                        cmd.CommandText = "select f1, sql_variant_property(f1,'BaseType') as BaseType from @tvpParam";
-                        SqlParameter p = cmd.Parameters.AddWithValue("@tvpParam", record);
-                        p.SqlDbType = SqlDbType.Structured;
-                        p.TypeName = string.Format("dbo.{0}", tvpTypeName);
-                        using (SqlDataReader dr = cmd.ExecuteReader())
-                        {
-                            dr.Read();
-                            VerifyReaderTypeAndValue("Test SqlDataRecord Parameter To TVP [Variant Type]", "SqlDbType.Variant", dr, expectedTypeName, expectedBaseTypeName, paramValue);
-                            dr.Dispose();
-                        }
-                    }
+                    dr.Read();
+                    VerifyReaderTypeAndValue("Test SqlDataRecord Parameter To TVP [Variant Type]", "SqlDbType.Variant", dr, expectedTypeName, expectedBaseTypeName, paramValue);
                 }
             }
             catch (Exception e)
@@ -261,11 +235,9 @@ private static void TestSqlDataRecordParameterToTVP_Variant(object paramValue, s
             }
             finally
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
-                {
-                    conn.Open();
-                    DropType(conn, tvpTypeName);
-                }
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropType(conn, tvpTypeName);
             }
         }
 
@@ -276,41 +248,29 @@ private static void TestSqlDataReaderParameterToTVP_Type(object paramValue, stri
             string tvpTypeName = DataTestUtility.GetUniqueNameForSqlServer("tvpType");
             try
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropType(conn, tvpTypeName);
+                xsql(conn, string.Format("create type dbo.{0} as table (f1 {1})", tvpTypeName, expectedBaseTypeName));
+                using (SqlConnection connInput = new(s_connStr))
                 {
-                    conn.Open();
-                    DropType(conn, tvpTypeName);
-                    xsql(conn, string.Format("create type dbo.{0} as table (f1 {1})", tvpTypeName, expectedBaseTypeName));
-
-                    // Send TVP using SqlDataReader.
-                    using (SqlConnection connInput = new SqlConnection(s_connStr))
+                    connInput.Open();
+                    using (SqlCommand cmdInput = connInput.CreateCommand())
                     {
-                        connInput.Open();
-
-                        using (SqlCommand cmdInput = connInput.CreateCommand())
+                        cmdInput.CommandText = "select @p1 as f1";
+                        cmdInput.Parameters.Add("@p1", GetSqlDbType(expectedBaseTypeName));
+                        cmdInput.Parameters["@p1"].Value = paramValue;
+                        using SqlDataReader drInput = cmdInput.ExecuteReader(CommandBehavior.CloseConnection);
+                        using SqlCommand cmd = conn.CreateCommand();
+                        cmd.CommandText = "select f1 from @tvpParam";
+                        SqlParameter p = cmd.Parameters.AddWithValue("@tvpParam", drInput);
+                        p.SqlDbType = SqlDbType.Structured;
+                        p.TypeName = string.Format("dbo.{0}", tvpTypeName);
+                        using (SqlDataReader dr = cmd.ExecuteReader())
                         {
-                            cmdInput.CommandText = "select @p1 as f1";
-                            cmdInput.Parameters.Add("@p1", GetSqlDbType(expectedBaseTypeName));
-                            cmdInput.Parameters["@p1"].Value = paramValue;
-
-                            using (SqlDataReader drInput = cmdInput.ExecuteReader(CommandBehavior.CloseConnection))
-                            {
-                                using (SqlCommand cmd = conn.CreateCommand())
-                                {
-                                    cmd.CommandText = "select f1 from @tvpParam";
-                                    SqlParameter p = cmd.Parameters.AddWithValue("@tvpParam", drInput);
-                                    p.SqlDbType = SqlDbType.Structured;
-                                    p.TypeName = string.Format("dbo.{0}", tvpTypeName);
-                                    using (SqlDataReader dr = cmd.ExecuteReader())
-                                    {
-                                        dr.Read();
-                                        VerifyReaderTypeAndValue("Test SqlDataReader Parameter To TVP [Data Type]", expectedBaseTypeName, expectedTypeName, dr[0], expectedTypeName, paramValue);
-                                        dr.Dispose();
-                                    }
-                                }
-                            }
+                            dr.Read();
+                            VerifyReaderTypeAndValue("Test SqlDataReader Parameter To TVP [Data Type]", expectedBaseTypeName, expectedTypeName, dr[0], expectedTypeName, paramValue);
                         }
-                        connInput.Close();
                     }
                 }
             }
@@ -323,11 +283,9 @@ private static void TestSqlDataReaderParameterToTVP_Type(object paramValue, stri
             }
             finally
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
-                {
-                    conn.Open();
-                    DropType(conn, tvpTypeName);
-                }
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropType(conn, tvpTypeName);
             }
         }
 
@@ -340,39 +298,31 @@ private static void TestSqlDataReaderParameterToTVP_Variant(object paramValue, s
             string tvpTypeName = DataTestUtility.GetUniqueNameForSqlServer("tvpVariant");
             try
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
-                {
-                    conn.Open();
-                    DropType(conn, tvpTypeName);
-                    xsql(conn, string.Format("create type dbo.{0} as table (f1 sql_variant)", tvpTypeName));
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropType(conn, tvpTypeName);
+                xsql(conn, string.Format("create type dbo.{0} as table (f1 sql_variant)", tvpTypeName));
 
-                    // Send TVP using SqlDataReader.
-                    using (SqlConnection connInput = new SqlConnection(s_connStr))
+                // Send TVP using SqlDataReader.
+                using (SqlConnection connInput = new(s_connStr))
+                {
+                    connInput.Open();
+                    using (SqlCommand cmdInput = connInput.CreateCommand())
                     {
-                        connInput.Open();
-                        using (SqlCommand cmdInput = connInput.CreateCommand())
+                        cmdInput.CommandText = "select @p1 as f1";
+                        cmdInput.Parameters.Add("@p1", SqlDbType.Variant);
+                        cmdInput.Parameters["@p1"].Value = paramValue;
+                        using SqlDataReader drInput = cmdInput.ExecuteReader(CommandBehavior.CloseConnection);
+                        using SqlCommand cmd = conn.CreateCommand();
+                        cmd.CommandText = "select f1, sql_variant_property(f1,'BaseType') as BaseType from @tvpParam";
+                        SqlParameter p = cmd.Parameters.AddWithValue("@tvpParam", drInput);
+                        p.SqlDbType = SqlDbType.Structured;
+                        p.TypeName = string.Format("dbo.{0}", tvpTypeName);
+                        using (SqlDataReader dr = cmd.ExecuteReader())
                         {
-                            cmdInput.CommandText = "select @p1 as f1";
-                            cmdInput.Parameters.Add("@p1", SqlDbType.Variant);
-                            cmdInput.Parameters["@p1"].Value = paramValue;
-                            using (SqlDataReader drInput = cmdInput.ExecuteReader(CommandBehavior.CloseConnection))
-                            {
-                                using (SqlCommand cmd = conn.CreateCommand())
-                                {
-                                    cmd.CommandText = "select f1, sql_variant_property(f1,'BaseType') as BaseType from @tvpParam";
-                                    SqlParameter p = cmd.Parameters.AddWithValue("@tvpParam", drInput);
-                                    p.SqlDbType = SqlDbType.Structured;
-                                    p.TypeName = string.Format("dbo.{0}", tvpTypeName);
-                                    using (SqlDataReader dr = cmd.ExecuteReader())
-                                    {
-                                        dr.Read();
-                                        VerifyReaderTypeAndValue("Test SqlDataReader Parameter To TVP [Variant Type]", "SqlDbType.Variant", dr, expectedTypeName, expectedBaseTypeName, paramValue);
-                                        dr.Dispose();
-                                    }
-                                }
-                            }
+                            dr.Read();
+                            VerifyReaderTypeAndValue("Test SqlDataReader Parameter To TVP [Variant Type]", "SqlDbType.Variant", dr, expectedTypeName, expectedBaseTypeName, paramValue);
                         }
-                        connInput.Close();
                     }
                 }
             }
@@ -385,11 +335,9 @@ private static void TestSqlDataReaderParameterToTVP_Variant(object paramValue, s
             }
             finally
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
-                {
-                    conn.Open();
-                    DropType(conn, tvpTypeName);
-                }
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropType(conn, tvpTypeName);
             }
         }
 
@@ -405,61 +353,56 @@ private static void TestSqlDataReader_TVP_Type(object paramValue, string expecte
             string ProcName = DataTestUtility.GetUniqueNameForSqlServer("spTVPProc");
             try
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
-                {
-                    conn.Open();
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
 
-                    DropStoredProcedure(conn, ProcName);
-                    DropTable(conn, InputTableName);
-                    DropTable(conn, OutputTableName);
-                    DropType(conn, $"dbo.{tvpTypeName}");
+                DropStoredProcedure(conn, ProcName);
+                DropTable(conn, InputTableName);
+                DropTable(conn, OutputTableName);
+                DropType(conn, $"dbo.{tvpTypeName}");
 
-                    xsql(conn, string.Format("create type dbo.{0} as table (f1 {1})", tvpTypeName, expectedBaseTypeName));
-                    xsql(conn, string.Format("create table {0} (f1 {1})", InputTableName, expectedBaseTypeName));
-                    xsql(conn, string.Format("create table {0} (f1 {1})", OutputTableName, expectedBaseTypeName));
+                xsql(conn, string.Format("create type dbo.{0} as table (f1 {1})", tvpTypeName, expectedBaseTypeName));
+                xsql(conn, string.Format("create table {0} (f1 {1})", InputTableName, expectedBaseTypeName));
+                xsql(conn, string.Format("create table {0} (f1 {1})", OutputTableName, expectedBaseTypeName));
 
-                    string value = string.Empty;
-                    if (paramValue.GetType() == typeof(System.DateTimeOffset))
-                    {
-                        DateTime dt = ((System.DateTimeOffset)paramValue).UtcDateTime;
-                        value = dt.ToString("M/d/yyyy") + " " + dt.TimeOfDay;
-                    }
-                    else if (paramValue.GetType() == typeof(System.TimeSpan))
-                    {
-                        value = ((System.TimeSpan)paramValue).ToString();
-                    }
-                    else
-                    {
-                        value = ((System.DateTime)paramValue).ToString("M/d/yyyy") + " " + ((System.DateTime)paramValue).TimeOfDay;
-                    }
-                    xsql(conn, string.Format("insert into {0} values(CAST('{1}' AS {2}))", InputTableName, value, expectedBaseTypeName));
-                    xsql(conn, string.Format("create proc {0} (@P {1} READONLY) as begin insert into {2} select * from @P; end", ProcName, tvpTypeName, OutputTableName));
+                string value = string.Empty;
+                if (paramValue.GetType() == typeof(DateTimeOffset))
+                {
+                    DateTime dt = ((DateTimeOffset)paramValue).UtcDateTime;
+                    value = dt.ToString("M/d/yyyy") + " " + dt.TimeOfDay;
+                }
+                else if (paramValue.GetType() == typeof(TimeSpan))
+                {
+                    value = ((TimeSpan)paramValue).ToString();
+                }
+                else
+                {
+                    value = ((DateTime)paramValue).ToString("M/d/yyyy") + " " + ((DateTime)paramValue).TimeOfDay;
+                }
+                xsql(conn, string.Format("insert into {0} values(CAST('{1}' AS {2}))", InputTableName, value, expectedBaseTypeName));
+                xsql(conn, string.Format("create proc {0} (@P {1} READONLY) as begin insert into {2} select * from @P; end", ProcName, tvpTypeName, OutputTableName));
 
-                    SqlCommand cmd = conn.CreateCommand();
-                    cmd.CommandText = string.Format("SELECT * FROM {0}", InputTableName);
-                    using (SqlDataReader r = cmd.ExecuteReader())
+                SqlCommand cmd = conn.CreateCommand();
+                cmd.CommandText = string.Format("SELECT * FROM {0}", InputTableName);
+                using SqlDataReader r = cmd.ExecuteReader();
+                using (SqlConnection conn2 = new(s_connStr))
+                {
+                    conn2.Open();
+                    SqlCommand cmd2 = new(ProcName, conn2)
                     {
-                        using (SqlConnection conn2 = new SqlConnection(s_connStr))
-                        {
-                            conn2.Open();
-                            SqlCommand cmd2 = new SqlCommand(ProcName, conn2);
-                            cmd2.CommandType = CommandType.StoredProcedure;
-                            SqlParameter p = cmd2.Parameters.AddWithValue("@P", r);
-                            p.SqlDbType = SqlDbType.Structured;
-                            p.TypeName = tvpTypeName;
-                            cmd2.ExecuteNonQuery();
-
-                            cmd2.CommandText = string.Format("SELECT f1 FROM {0}", OutputTableName);
-                            ;
-                            cmd2.CommandType = CommandType.Text;
-                            using (SqlDataReader dr = cmd2.ExecuteReader())
-                            {
-                                dr.Read();
-                                VerifyReaderTypeAndValue("Test SqlDataReader TVP [Data Type]", expectedBaseTypeName, expectedTypeName, dr[0], expectedTypeName, paramValue);
-                                dr.Dispose();
-                            }
-                            conn2.Close();
-                        }
+                        CommandType = CommandType.StoredProcedure
+                    };
+                    SqlParameter p = cmd2.Parameters.AddWithValue("@P", r);
+                    p.SqlDbType = SqlDbType.Structured;
+                    p.TypeName = tvpTypeName;
+                    cmd2.ExecuteNonQuery();
+
+                    cmd2.CommandText = string.Format("SELECT f1 FROM {0}", OutputTableName);
+                    cmd2.CommandType = CommandType.Text;
+                    using (SqlDataReader dr = cmd2.ExecuteReader())
+                    {
+                        dr.Read();
+                        VerifyReaderTypeAndValue("Test SqlDataReader TVP [Data Type]", expectedBaseTypeName, expectedTypeName, dr[0], expectedTypeName, paramValue);
                     }
                 }
             }
@@ -472,14 +415,12 @@ private static void TestSqlDataReader_TVP_Type(object paramValue, string expecte
             }
             finally
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
-                {
-                    conn.Open();
-                    DropStoredProcedure(conn, ProcName);
-                    DropTable(conn, InputTableName);
-                    DropTable(conn, OutputTableName);
-                    DropType(conn, tvpTypeName);
-                }
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropStoredProcedure(conn, ProcName);
+                DropTable(conn, InputTableName);
+                DropTable(conn, OutputTableName);
+                DropType(conn, tvpTypeName);
             }
         }
 
@@ -493,60 +434,56 @@ private static void TestSqlDataReader_TVP_Variant(object paramValue, string expe
             string ProcName = DataTestUtility.GetUniqueNameForSqlServer("spTVPProc_DRdrTVPVar");
             try
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
-                {
-                    conn.Open();
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
 
-                    DropStoredProcedure(conn, ProcName);
-                    DropTable(conn, InputTableName);
-                    DropTable(conn, OutputTableName);
-                    DropType(conn, tvpTypeName);
+                DropStoredProcedure(conn, ProcName);
+                DropTable(conn, InputTableName);
+                DropTable(conn, OutputTableName);
+                DropType(conn, tvpTypeName);
 
-                    xsql(conn, string.Format("create type {0} as table (f1 sql_variant)", tvpTypeName));
-                    xsql(conn, string.Format("create table {0} (f1 sql_variant)", InputTableName));
-                    xsql(conn, string.Format("create table {0} (f1 sql_variant)", OutputTableName));
+                xsql(conn, string.Format("create type {0} as table (f1 sql_variant)", tvpTypeName));
+                xsql(conn, string.Format("create table {0} (f1 sql_variant)", InputTableName));
+                xsql(conn, string.Format("create table {0} (f1 sql_variant)", OutputTableName));
 
-                    string value = string.Empty;
-                    if (paramValue.GetType() == typeof(System.DateTimeOffset))
-                    {
-                        DateTime dt = ((System.DateTimeOffset)paramValue).UtcDateTime;
-                        value = dt.ToString("M/d/yyyy") + " " + dt.TimeOfDay;
-                    }
-                    else if (paramValue.GetType() == typeof(System.TimeSpan))
-                    {
-                        value = ((System.TimeSpan)paramValue).ToString();
-                    }
-                    else
-                    {
-                        value = ((System.DateTime)paramValue).ToString("M/d/yyyy") + " " + ((System.DateTime)paramValue).TimeOfDay;
-                    }
-                    xsql(conn, string.Format("insert into {0} values(CAST('{1}' AS {2}))", InputTableName, value, expectedBaseTypeName));
-                    xsql(conn, string.Format("create proc {0} (@P {1} READONLY) as begin insert into {2} select * from @P; end", ProcName, tvpTypeName, OutputTableName));
+                string value = string.Empty;
+                if (paramValue.GetType() == typeof(DateTimeOffset))
+                {
+                    DateTime dt = ((DateTimeOffset)paramValue).UtcDateTime;
+                    value = dt.ToString("M/d/yyyy") + " " + dt.TimeOfDay;
+                }
+                else if (paramValue.GetType() == typeof(TimeSpan))
+                {
+                    value = ((TimeSpan)paramValue).ToString();
+                }
+                else
+                {
+                    value = ((DateTime)paramValue).ToString("M/d/yyyy") + " " + ((DateTime)paramValue).TimeOfDay;
+                }
+                xsql(conn, string.Format("insert into {0} values(CAST('{1}' AS {2}))", InputTableName, value, expectedBaseTypeName));
+                xsql(conn, string.Format("create proc {0} (@P {1} READONLY) as begin insert into {2} select * from @P; end", ProcName, tvpTypeName, OutputTableName));
 
-                    SqlCommand cmd = conn.CreateCommand();
-                    cmd.CommandText = string.Format("SELECT * FROM {0}", InputTableName);
-                    using (SqlDataReader r = cmd.ExecuteReader())
+                SqlCommand cmd = conn.CreateCommand();
+                cmd.CommandText = string.Format("SELECT * FROM {0}", InputTableName);
+                using SqlDataReader r = cmd.ExecuteReader();
+                using (SqlConnection conn2 = new(s_connStr))
+                {
+                    conn2.Open();
+                    using (SqlCommand cmd2 = new(ProcName, conn2))
                     {
-                        using (SqlConnection conn2 = new SqlConnection(s_connStr))
+                        cmd2.CommandType = CommandType.StoredProcedure;
+                        SqlParameter p = cmd2.Parameters.AddWithValue("@P", r);
+                        p.SqlDbType = SqlDbType.Structured;
+                        p.TypeName = tvpTypeName;
+                        cmd2.ExecuteNonQuery();
+
+                        cmd2.CommandText = string.Format("SELECT f1, sql_variant_property(f1,'BaseType') as BaseType FROM {0}", OutputTableName);
+                        ;
+                        cmd2.CommandType = CommandType.Text;
+                        using (SqlDataReader dr = cmd2.ExecuteReader())
                         {
-                            conn2.Open();
-                            SqlCommand cmd2 = new SqlCommand(ProcName, conn2);
-                            cmd2.CommandType = CommandType.StoredProcedure;
-                            SqlParameter p = cmd2.Parameters.AddWithValue("@P", r);
-                            p.SqlDbType = SqlDbType.Structured;
-                            p.TypeName = tvpTypeName;
-                            cmd2.ExecuteNonQuery();
-
-                            cmd2.CommandText = string.Format("SELECT f1, sql_variant_property(f1,'BaseType') as BaseType FROM {0}", OutputTableName);
-                            ;
-                            cmd2.CommandType = CommandType.Text;
-                            using (SqlDataReader dr = cmd2.ExecuteReader())
-                            {
-                                dr.Read();
-                                VerifyReaderTypeAndValue("Test SqlDataReader TVP [Variant Type]", "SqlDbType.Variant", dr, expectedTypeName, expectedBaseTypeName, paramValue);
-                                dr.Dispose();
-                            }
-                            conn2.Close();
+                            dr.Read();
+                            VerifyReaderTypeAndValue("Test SqlDataReader TVP [Variant Type]", "SqlDbType.Variant", dr, expectedTypeName, expectedBaseTypeName, paramValue);
                         }
                     }
                 }
@@ -560,14 +497,12 @@ private static void TestSqlDataReader_TVP_Variant(object paramValue, string expe
             }
             finally
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
-                {
-                    conn.Open();
-                    DropStoredProcedure(conn, ProcName);
-                    DropTable(conn, InputTableName);
-                    DropTable(conn, OutputTableName);
-                    DropType(conn, tvpTypeName);
-                }
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropStoredProcedure(conn, ProcName);
+                DropTable(conn, InputTableName);
+                DropTable(conn, OutputTableName);
+                DropType(conn, tvpTypeName);
             }
         }
 
@@ -581,41 +516,36 @@ private static void TestSimpleDataReader_Type(object paramValue, string expected
             string procName = DataTestUtility.GetUniqueNameForSqlServer("paramProc3");
             try
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
-                {
-                    conn.Open();
-                    DropTable(conn, inputTable);
-                    DropStoredProcedure(conn, procName);
-
-                    string value = string.Empty;
-                    if (paramValue.GetType() == typeof(System.DateTimeOffset))
-                    {
-                        DateTime dt = ((System.DateTimeOffset)paramValue).UtcDateTime;
-                        value = dt.ToString("M/d/yyyy") + " " + dt.TimeOfDay;
-                    }
-                    else if (paramValue.GetType() == typeof(System.TimeSpan))
-                    {
-                        value = ((System.TimeSpan)paramValue).ToString();
-                    }
-                    else
-                    {
-                        value = ((System.DateTime)paramValue).ToString("M/d/yyyy") + " " + ((System.DateTime)paramValue).TimeOfDay;
-                    }
-                    xsql(conn, string.Format("create table {0} (f1 {1})", inputTable, expectedBaseTypeName));
-                    xsql(conn, string.Format("insert into {0}(f1) values('{1}');", inputTable, value));
-                    xsql(conn, string.Format("create proc {0} as begin select f1 from {1} end;", procName, inputTable));
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropTable(conn, inputTable);
+                DropStoredProcedure(conn, procName);
 
-                    using (SqlCommand cmd = conn.CreateCommand())
-                    {
-                        cmd.CommandText = procName;
-                        cmd.CommandType = CommandType.StoredProcedure;
-                        using (SqlDataReader dr = cmd.ExecuteReader())
-                        {
-                            dr.Read();
-                            VerifyReaderTypeAndValue("Test Simple Data Reader [Data Type]", expectedBaseTypeName, expectedTypeName, dr[0], expectedTypeName, paramValue);
-                            dr.Dispose();
-                        }
-                    }
+                string value = string.Empty;
+                if (paramValue.GetType() == typeof(DateTimeOffset))
+                {
+                    DateTime dt = ((DateTimeOffset)paramValue).UtcDateTime;
+                    value = dt.ToString("M/d/yyyy") + " " + dt.TimeOfDay;
+                }
+                else if (paramValue.GetType() == typeof(TimeSpan))
+                {
+                    value = ((TimeSpan)paramValue).ToString();
+                }
+                else
+                {
+                    value = ((DateTime)paramValue).ToString("M/d/yyyy") + " " + ((DateTime)paramValue).TimeOfDay;
+                }
+                xsql(conn, string.Format("create table {0} (f1 {1})", inputTable, expectedBaseTypeName));
+                xsql(conn, string.Format("insert into {0}(f1) values('{1}');", inputTable, value));
+                xsql(conn, string.Format("create proc {0} as begin select f1 from {1} end;", procName, inputTable));
+
+                using SqlCommand cmd = conn.CreateCommand();
+                cmd.CommandText = procName;
+                cmd.CommandType = CommandType.StoredProcedure;
+                using (SqlDataReader dr = cmd.ExecuteReader())
+                {
+                    dr.Read();
+                    VerifyReaderTypeAndValue("Test Simple Data Reader [Data Type]", expectedBaseTypeName, expectedTypeName, dr[0], expectedTypeName, paramValue);
                 }
             }
             catch (Exception e)
@@ -627,12 +557,10 @@ private static void TestSimpleDataReader_Type(object paramValue, string expected
             }
             finally
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
-                {
-                    conn.Open();
-                    DropStoredProcedure(conn, procName);
-                    DropTable(conn, inputTable);
-                }
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropStoredProcedure(conn, procName);
+                DropTable(conn, inputTable);
             }
         }
 
@@ -644,41 +572,36 @@ private static void TestSimpleDataReader_Variant(object paramValue, string expec
             string procName = DataTestUtility.GetUniqueNameForSqlServer("paramProc4");
             try
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
-                {
-                    conn.Open();
-                    DropTable(conn, inputTable);
-                    DropStoredProcedure(conn, procName);
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropTable(conn, inputTable);
+                DropStoredProcedure(conn, procName);
 
-                    string value = string.Empty;
-                    if (paramValue.GetType() == typeof(System.DateTimeOffset))
-                    {
-                        DateTime dt = ((System.DateTimeOffset)paramValue).UtcDateTime;
-                        value = dt.ToString("M/d/yyyy") + " " + dt.TimeOfDay;
-                    }
-                    else if (paramValue.GetType() == typeof(System.TimeSpan))
-                    {
-                        value = ((System.TimeSpan)paramValue).ToString();
-                    }
-                    else
-                    {
-                        value = ((System.DateTime)paramValue).ToString("M/d/yyyy") + " " + ((System.DateTime)paramValue).TimeOfDay;
-                    }
-                    xsql(conn, string.Format("create table {0} (f1 sql_variant)", inputTable));
-                    xsql(conn, string.Format("insert into {0}(f1) values(CAST('{1}' AS {2}));", inputTable, value, expectedBaseTypeName));
-                    xsql(conn, string.Format("create proc {0} as begin select f1, sql_variant_property(f1,'BaseType') as BaseType from {1} end;", procName, inputTable));
-
-                    using (SqlCommand cmd = conn.CreateCommand())
-                    {
-                        cmd.CommandText = procName;
-                        cmd.CommandType = CommandType.StoredProcedure;
-                        using (SqlDataReader dr = cmd.ExecuteReader())
-                        {
-                            dr.Read();
-                            VerifyReaderTypeAndValue("Test Simple Data Reader [Variant Type]", "SqlDbType.Variant", dr, expectedTypeName, expectedBaseTypeName, paramValue);
-                            dr.Dispose();
-                        }
-                    }
+                string value = string.Empty;
+                if (paramValue.GetType() == typeof(DateTimeOffset))
+                {
+                    DateTime dt = ((DateTimeOffset)paramValue).UtcDateTime;
+                    value = dt.ToString("M/d/yyyy") + " " + dt.TimeOfDay;
+                }
+                else if (paramValue.GetType() == typeof(TimeSpan))
+                {
+                    value = ((TimeSpan)paramValue).ToString();
+                }
+                else
+                {
+                    value = ((DateTime)paramValue).ToString("M/d/yyyy") + " " + ((DateTime)paramValue).TimeOfDay;
+                }
+                xsql(conn, string.Format("create table {0} (f1 sql_variant)", inputTable));
+                xsql(conn, string.Format("insert into {0}(f1) values(CAST('{1}' AS {2}));", inputTable, value, expectedBaseTypeName));
+                xsql(conn, string.Format("create proc {0} as begin select f1, sql_variant_property(f1,'BaseType') as BaseType from {1} end;", procName, inputTable));
+
+                using SqlCommand cmd = conn.CreateCommand();
+                cmd.CommandText = procName;
+                cmd.CommandType = CommandType.StoredProcedure;
+                using (SqlDataReader dr = cmd.ExecuteReader())
+                {
+                    dr.Read();
+                    VerifyReaderTypeAndValue("Test Simple Data Reader [Variant Type]", "SqlDbType.Variant", dr, expectedTypeName, expectedBaseTypeName, paramValue);
                 }
             }
             catch (Exception e)
@@ -690,12 +613,10 @@ private static void TestSimpleDataReader_Variant(object paramValue, string expec
             }
             finally
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
-                {
-                    conn.Open();
-                    DropStoredProcedure(conn, procName);
-                    DropTable(conn, inputTable);
-                }
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropStoredProcedure(conn, procName);
+                DropTable(conn, inputTable);
             }
         }
 
@@ -707,63 +628,54 @@ private static void SqlBulkCopySqlDataReader_Type(object paramValue, string expe
             string bulkCopyTableName = DataTestUtility.GetUniqueNameForSqlServer("bulkDestTable");
             try
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropTable(conn, bulkCopyTableName);
+                xsql(conn, string.Format("create table {0} (f1 {1})", bulkCopyTableName, expectedBaseTypeName));
+
+                DropTable(conn, bulkCopySrcTableName);
+                xsql(conn, string.Format("create table {0} (f1 {1})", bulkCopySrcTableName, expectedBaseTypeName));
+                string value = string.Empty;
+                if (paramValue.GetType() == typeof(DateTimeOffset))
                 {
-                    conn.Open();
-                    DropTable(conn, bulkCopyTableName);
-                    xsql(conn, string.Format("create table {0} (f1 {1})", bulkCopyTableName, expectedBaseTypeName));
-
-                    DropTable(conn, bulkCopySrcTableName);
-                    xsql(conn, string.Format("create table {0} (f1 {1})", bulkCopySrcTableName, expectedBaseTypeName));
-                    string value = string.Empty;
-                    if (paramValue.GetType() == typeof(System.DateTimeOffset))
-                    {
-                        DateTime dt = ((System.DateTimeOffset)paramValue).UtcDateTime;
-                        value = dt.ToString("M/d/yyyy") + " " + dt.TimeOfDay;
-                    }
-                    else if (paramValue.GetType() == typeof(System.TimeSpan))
-                    {
-                        value = ((System.TimeSpan)paramValue).ToString();
-                    }
-                    else
+                    DateTime dt = ((DateTimeOffset)paramValue).UtcDateTime;
+                    value = dt.ToString("M/d/yyyy") + " " + dt.TimeOfDay;
+                }
+                else if (paramValue.GetType() == typeof(TimeSpan))
+                {
+                    value = ((TimeSpan)paramValue).ToString();
+                }
+                else
+                {
+                    value = ((DateTime)paramValue).ToString("M/d/yyyy") + " " + ((DateTime)paramValue).TimeOfDay;
+                }
+                xsql(conn, string.Format("insert into {0}(f1) values(CAST('{1}' AS {2}));", bulkCopySrcTableName, value, expectedBaseTypeName));
+
+                using SqlConnection connInput = new(s_connStr);
+                connInput.Open();
+                using (SqlCommand cmdInput = connInput.CreateCommand())
+                {
+                    cmdInput.CommandText = string.Format("select * from {0}", bulkCopySrcTableName);
+                    using SqlDataReader drInput = cmdInput.ExecuteReader();
+                    // Perform bulk copy to target.
+                    using (SqlBulkCopy bulkCopy = new(conn))
                     {
-                        value = ((System.DateTime)paramValue).ToString("M/d/yyyy") + " " + ((System.DateTime)paramValue).TimeOfDay;
+                        bulkCopy.BulkCopyTimeout = 60;
+                        bulkCopy.BatchSize = 1;
+                        bulkCopy.DestinationTableName = bulkCopyTableName;
+                        bulkCopy.WriteToServer(drInput);
                     }
-                    xsql(conn, string.Format("insert into {0}(f1) values(CAST('{1}' AS {2}));", bulkCopySrcTableName, value, expectedBaseTypeName));
 
-                    using (SqlConnection connInput = new SqlConnection(s_connStr))
+                    // Verify target.
+                    using SqlCommand cmd = conn.CreateCommand();
+                    cmd.CommandText = string.Format("select f1 from {0}", bulkCopyTableName);
+                    using (SqlDataReader drVerify = cmd.ExecuteReader())
                     {
-                        connInput.Open();
-                        using (SqlCommand cmdInput = connInput.CreateCommand())
-                        {
-                            cmdInput.CommandText = string.Format("select * from {0}", bulkCopySrcTableName);
-                            using (SqlDataReader drInput = cmdInput.ExecuteReader())
-                            {
-                                // Perform bulk copy to target.
-                                using (SqlBulkCopy bulkCopy = new SqlBulkCopy(conn))
-                                {
-                                    bulkCopy.BulkCopyTimeout = 60;
-                                    bulkCopy.BatchSize = 1;
-                                    bulkCopy.DestinationTableName = bulkCopyTableName;
-                                    bulkCopy.WriteToServer(drInput);
-                                }
-
-                                // Verify target.
-                                using (SqlCommand cmd = conn.CreateCommand())
-                                {
-                                    cmd.CommandText = string.Format("select f1 from {0}", bulkCopyTableName);
-                                    using (SqlDataReader drVerify = cmd.ExecuteReader())
-                                    {
-                                        drVerify.Read();
-                                        VerifyReaderTypeAndValue("SqlBulkCopy From SqlDataReader [Data Type]", expectedBaseTypeName, expectedTypeName, drVerify[0], expectedTypeName, paramValue);
-                                        drVerify.Dispose();
-                                    }
-                                }
-                            }
-                        }
-                        connInput.Close();
+                        drVerify.Read();
+                        VerifyReaderTypeAndValue("SqlBulkCopy From SqlDataReader [Data Type]", expectedBaseTypeName, expectedTypeName, drVerify[0], expectedTypeName, paramValue);
                     }
                 }
+                connInput.Close();
             }
             catch (Exception e)
             {
@@ -774,12 +686,10 @@ private static void SqlBulkCopySqlDataReader_Type(object paramValue, string expe
             }
             finally
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
-                {
-                    conn.Open();
-                    DropTable(conn, bulkCopyTableName);
-                    DropTable(conn, bulkCopySrcTableName);
-                }
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropTable(conn, bulkCopyTableName);
+                DropTable(conn, bulkCopySrcTableName);
             }
 
         }
@@ -792,67 +702,59 @@ private static void SqlBulkCopySqlDataReader_Variant(object paramValue, string e
             string bulkCopyTableName = DataTestUtility.GetUniqueNameForSqlServer("bulkDestTable");
             try
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropTable(conn, bulkCopyTableName);
+                xsql(conn, string.Format("create table {0} (f1 sql_variant)", bulkCopyTableName));
+
+                DropTable(conn, bulkCopySrcTableName);
+                xsql(conn, string.Format("create table {0} (f1 {1})", bulkCopySrcTableName, expectedBaseTypeName));
+                string value = string.Empty;
+                if (paramValue.GetType() == typeof(DateTimeOffset))
                 {
-                    conn.Open();
-                    DropTable(conn, bulkCopyTableName);
-                    xsql(conn, string.Format("create table {0} (f1 sql_variant)", bulkCopyTableName));
-
-                    DropTable(conn, bulkCopySrcTableName);
-                    xsql(conn, string.Format("create table {0} (f1 {1})", bulkCopySrcTableName, expectedBaseTypeName));
-                    string value = string.Empty;
-                    if (paramValue.GetType() == typeof(System.DateTimeOffset))
-                    {
-                        DateTime dt = ((System.DateTimeOffset)paramValue).UtcDateTime;
-                        value = dt.ToString("M/d/yyyy") + " " + dt.TimeOfDay;
-                    }
-                    else if (paramValue.GetType() == typeof(System.TimeSpan))
-                    {
-                        value = ((System.TimeSpan)paramValue).ToString();
-                    }
-                    else
-                    {
-                        value = ((System.DateTime)paramValue).ToString("M/d/yyyy") + " " + ((System.DateTime)paramValue).TimeOfDay;
-                    }
-                    xsql(conn, string.Format("insert into {0}(f1) values(CAST('{1}' AS {2}));", bulkCopySrcTableName, value, expectedBaseTypeName));
+                    DateTime dt = ((DateTimeOffset)paramValue).UtcDateTime;
+                    value = dt.ToString("M/d/yyyy") + " " + dt.TimeOfDay;
+                }
+                else if (paramValue.GetType() == typeof(TimeSpan))
+                {
+                    value = ((TimeSpan)paramValue).ToString();
+                }
+                else
+                {
+                    value = ((DateTime)paramValue).ToString("M/d/yyyy") + " " + ((DateTime)paramValue).TimeOfDay;
+                }
+                xsql(conn, string.Format("insert into {0}(f1) values(CAST('{1}' AS {2}));", bulkCopySrcTableName, value, expectedBaseTypeName));
 
-                    using (SqlConnection connInput = new SqlConnection(s_connStr))
+                using (SqlConnection connInput = new(s_connStr))
+                {
+                    connInput.Open();
+                    using (SqlCommand cmdInput = connInput.CreateCommand())
                     {
-                        connInput.Open();
-                        using (SqlCommand cmdInput = connInput.CreateCommand())
+                        cmdInput.CommandText = string.Format("select * from {0}", bulkCopySrcTableName);
+                        using SqlDataReader drInput = cmdInput.ExecuteReader();
                         {
-                            cmdInput.CommandText = string.Format("select * from {0}", bulkCopySrcTableName);
-                            using (SqlDataReader drInput = cmdInput.ExecuteReader())
+                            // Perform bulk copy to target.
+                            using (SqlBulkCopy bulkCopy = new(conn))
                             {
-                                {
-                                    // Perform bulk copy to target.
-                                    using (SqlBulkCopy bulkCopy = new SqlBulkCopy(conn))
-                                    {
-                                        bulkCopy.BulkCopyTimeout = 60;
-                                        bulkCopy.BatchSize = 1;
-                                        bulkCopy.DestinationTableName = bulkCopyTableName;
-                                        bulkCopy.WriteToServer(drInput);
-                                    }
-
-                                    // Verify target.
-                                    using (SqlCommand cmd = conn.CreateCommand())
-                                    {
-                                        cmd.CommandText = string.Format("select f1, sql_variant_property(f1,'BaseType') as BaseType from {0}", bulkCopyTableName);
-                                        using (SqlDataReader drVerify = cmd.ExecuteReader())
-                                        {
-                                            drVerify.Read();
-                                            VerifyReaderTypeAndValue("SqlBulkCopy From SqlDataReader [Variant Type]", "SqlDbType.Variant", drVerify, expectedTypeName, expectedBaseTypeName, paramValue);
-                                            drVerify.Dispose();
-                                        }
-                                    }
-                                }
+                                bulkCopy.BulkCopyTimeout = 60;
+                                bulkCopy.BatchSize = 1;
+                                bulkCopy.DestinationTableName = bulkCopyTableName;
+                                bulkCopy.WriteToServer(drInput);
+                            }
+
+                            // Verify target.
+                            using SqlCommand cmd = conn.CreateCommand();
+                            cmd.CommandText = string.Format("select f1, sql_variant_property(f1,'BaseType') as BaseType from {0}", bulkCopyTableName);
+                            using (SqlDataReader drVerify = cmd.ExecuteReader())
+                            {
+                                drVerify.Read();
+                                VerifyReaderTypeAndValue("SqlBulkCopy From SqlDataReader [Variant Type]", "SqlDbType.Variant", drVerify, expectedTypeName, expectedBaseTypeName, paramValue);
                             }
                         }
-                        connInput.Close();
                     }
-
-                    conn.Close();
                 }
+
+                conn.Close();
             }
             catch (Exception e)
             {
@@ -863,12 +765,10 @@ private static void SqlBulkCopySqlDataReader_Variant(object paramValue, string e
             }
             finally
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
-                {
-                    conn.Open();
-                    DropTable(conn, bulkCopyTableName);
-                    DropTable(conn, bulkCopySrcTableName);
-                }
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropTable(conn, bulkCopyTableName);
+                DropTable(conn, bulkCopySrcTableName);
             }
         }
 
@@ -879,37 +779,32 @@ private static void SqlBulkCopyDataTable_Type(object paramValue, string expected
             string bulkCopyTableName = DataTestUtility.GetUniqueNameForSqlServer("bulkDestType");
             try
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
-                {
-                    conn.Open();
-                    DropTable(conn, bulkCopyTableName);
-                    xsql(conn, string.Format("create table {0} (f1 {1})", bulkCopyTableName, expectedBaseTypeName));
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropTable(conn, bulkCopyTableName);
+                xsql(conn, string.Format("create table {0} (f1 {1})", bulkCopyTableName, expectedBaseTypeName));
 
-                    // Send using DataTable as source.
-                    DataTable t = new DataTable();
-                    t.Columns.Add("f1", paramValue.GetType());
-                    t.Rows.Add(new object[] { paramValue });
+                // Send using DataTable as source.
+                DataTable t = new();
+                t.Columns.Add("f1", paramValue.GetType());
+                t.Rows.Add(new object[] { paramValue });
 
-                    // Perform bulk copy to target.
-                    using (SqlBulkCopy bulkCopy = new SqlBulkCopy(conn))
-                    {
-                        bulkCopy.BulkCopyTimeout = 60;
-                        bulkCopy.BatchSize = 1;
-                        bulkCopy.DestinationTableName = bulkCopyTableName;
-                        bulkCopy.WriteToServer(t, DataRowState.Added);
-                    }
+                // Perform bulk copy to target.
+                using (SqlBulkCopy bulkCopy = new(conn))
+                {
+                    bulkCopy.BulkCopyTimeout = 60;
+                    bulkCopy.BatchSize = 1;
+                    bulkCopy.DestinationTableName = bulkCopyTableName;
+                    bulkCopy.WriteToServer(t, DataRowState.Added);
+                }
 
-                    // Verify target.
-                    using (SqlCommand cmd = conn.CreateCommand())
-                    {
-                        cmd.CommandText = string.Format("select f1 from {0}", bulkCopyTableName);
-                        using (SqlDataReader drVerify = cmd.ExecuteReader())
-                        {
-                            drVerify.Read();
-                            VerifyReaderTypeAndValue("SqlBulkCopy From Data Table [Data Type]", expectedBaseTypeName, expectedTypeName, drVerify[0], expectedTypeName, paramValue);
-                            drVerify.Dispose();
-                        }
-                    }
+                // Verify target.
+                using SqlCommand cmd = conn.CreateCommand();
+                cmd.CommandText = string.Format("select f1 from {0}", bulkCopyTableName);
+                using (SqlDataReader drVerify = cmd.ExecuteReader())
+                {
+                    drVerify.Read();
+                    VerifyReaderTypeAndValue("SqlBulkCopy From Data Table [Data Type]", expectedBaseTypeName, expectedTypeName, drVerify[0], expectedTypeName, paramValue);
                 }
             }
             catch (Exception e)
@@ -929,11 +824,9 @@ private static void SqlBulkCopyDataTable_Type(object paramValue, string expected
             }
             finally
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
-                {
-                    conn.Open();
-                    DropTable(conn, bulkCopyTableName);
-                }
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropTable(conn, bulkCopyTableName);
             }
         }
 
@@ -946,37 +839,32 @@ private static void SqlBulkCopyDataTable_Variant(object paramValue, string expec
             string bulkCopyTableName = DataTestUtility.GetUniqueNameForSqlServer("bulkDestVariant");
             try
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
-                {
-                    conn.Open();
-                    DropTable(conn, bulkCopyTableName);
-                    xsql(conn, string.Format("create table {0} (f1 sql_variant)", bulkCopyTableName));
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropTable(conn, bulkCopyTableName);
+                xsql(conn, string.Format("create table {0} (f1 sql_variant)", bulkCopyTableName));
 
-                    // Send using DataTable as source.
-                    DataTable t = new DataTable();
-                    t.Columns.Add("f1", typeof(object));
-                    t.Rows.Add(new object[] { paramValue });
+                // Send using DataTable as source.
+                DataTable t = new();
+                t.Columns.Add("f1", typeof(object));
+                t.Rows.Add(new object[] { paramValue });
 
-                    // Perform bulk copy to target.
-                    using (SqlBulkCopy bulkCopy = new SqlBulkCopy(conn))
-                    {
-                        bulkCopy.BulkCopyTimeout = 60;
-                        bulkCopy.BatchSize = 1;
-                        bulkCopy.DestinationTableName = bulkCopyTableName;
-                        bulkCopy.WriteToServer(t, DataRowState.Added);
-                    }
+                // Perform bulk copy to target.
+                using (SqlBulkCopy bulkCopy = new(conn))
+                {
+                    bulkCopy.BulkCopyTimeout = 60;
+                    bulkCopy.BatchSize = 1;
+                    bulkCopy.DestinationTableName = bulkCopyTableName;
+                    bulkCopy.WriteToServer(t, DataRowState.Added);
+                }
 
-                    // Verify target.
-                    using (SqlCommand cmd = conn.CreateCommand())
-                    {
-                        cmd.CommandText = string.Format("select f1, sql_variant_property(f1,'BaseType') as BaseType from {0}", bulkCopyTableName);
-                        using (SqlDataReader drVerify = cmd.ExecuteReader())
-                        {
-                            drVerify.Read();
-                            VerifyReaderTypeAndValue("SqlBulkCopy From Data Table [Variant Type]", "SqlDbType.Variant", drVerify, expectedTypeName, expectedBaseTypeName, paramValue);
-                            drVerify.Dispose();
-                        }
-                    }
+                // Verify target.
+                using SqlCommand cmd = conn.CreateCommand();
+                cmd.CommandText = string.Format("select f1, sql_variant_property(f1,'BaseType') as BaseType from {0}", bulkCopyTableName);
+                using (SqlDataReader drVerify = cmd.ExecuteReader())
+                {
+                    drVerify.Read();
+                    VerifyReaderTypeAndValue("SqlBulkCopy From Data Table [Variant Type]", "SqlDbType.Variant", drVerify, expectedTypeName, expectedBaseTypeName, paramValue);
                 }
             }
             catch (Exception e)
@@ -988,11 +876,9 @@ private static void SqlBulkCopyDataTable_Variant(object paramValue, string expec
             }
             finally
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
-                {
-                    conn.Open();
-                    DropTable(conn, bulkCopyTableName);
-                }
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropTable(conn, bulkCopyTableName);
             }
         }
 
@@ -1003,38 +889,27 @@ private static void SqlBulkCopyDataRow_Type(object paramValue, string expectedTy
             string bulkCopyTableName = DataTestUtility.GetUniqueNameForSqlServer("bulkDestType");
             try
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropTable(conn, bulkCopyTableName);
+                xsql(conn, string.Format("create table {0} (f1 {1})", bulkCopyTableName, expectedBaseTypeName));
+                DataTable t = new();
+                t.Columns.Add("f1", paramValue.GetType());
+                t.Rows.Add(new object[] { paramValue });
+                DataRow[] rowToSend = t.Select();
+                using (SqlBulkCopy bulkCopy = new(conn))
                 {
-                    conn.Open();
-                    DropTable(conn, bulkCopyTableName);
-                    xsql(conn, string.Format("create table {0} (f1 {1})", bulkCopyTableName, expectedBaseTypeName));
-
-                    DataTable t = new DataTable();
-                    t.Columns.Add("f1", paramValue.GetType());
-                    t.Rows.Add(new object[] { paramValue });
-                    // Send using DataRow as source.
-                    DataRow[] rowToSend = t.Select();
-
-                    // Perform bulk copy to target.
-                    using (SqlBulkCopy bulkCopy = new SqlBulkCopy(conn))
-                    {
-                        bulkCopy.BulkCopyTimeout = 60;
-                        bulkCopy.BatchSize = 1;
-                        bulkCopy.DestinationTableName = bulkCopyTableName;
-                        bulkCopy.WriteToServer(rowToSend);
-                    }
-
-                    // Verify target.
-                    using (SqlCommand cmd = conn.CreateCommand())
-                    {
-                        cmd.CommandText = string.Format("select f1 from {0}", bulkCopyTableName);
-                        using (SqlDataReader drVerify = cmd.ExecuteReader())
-                        {
-                            drVerify.Read();
-                            VerifyReaderTypeAndValue("SqlBulkCopy From Data Row [Data Type]", expectedBaseTypeName, expectedTypeName, drVerify[0], expectedTypeName, paramValue);
-                            drVerify.Dispose();
-                        }
-                    }
+                    bulkCopy.BulkCopyTimeout = 60;
+                    bulkCopy.BatchSize = 1;
+                    bulkCopy.DestinationTableName = bulkCopyTableName;
+                    bulkCopy.WriteToServer(rowToSend);
+                }
+                using SqlCommand cmd = conn.CreateCommand();
+                cmd.CommandText = string.Format("select f1 from {0}", bulkCopyTableName);
+                using (SqlDataReader drVerify = cmd.ExecuteReader())
+                {
+                    drVerify.Read();
+                    VerifyReaderTypeAndValue("SqlBulkCopy From Data Row [Data Type]", expectedBaseTypeName, expectedTypeName, drVerify[0], expectedTypeName, paramValue);
                 }
             }
             catch (Exception e)
@@ -1054,11 +929,9 @@ private static void SqlBulkCopyDataRow_Type(object paramValue, string expectedTy
             }
             finally
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
-                {
-                    conn.Open();
-                    DropTable(conn, bulkCopyTableName);
-                }
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropTable(conn, bulkCopyTableName);
             }
         }
 
@@ -1071,38 +944,27 @@ private static void SqlBulkCopyDataRow_Variant(object paramValue, string expecte
             string bulkCopyTableName = DataTestUtility.GetUniqueNameForSqlServer("bulkDestVariant");
             try
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropTable(conn, bulkCopyTableName);
+                xsql(conn, string.Format("create table {0} (f1 sql_variant)", bulkCopyTableName));
+                DataTable t = new();
+                t.Columns.Add("f1", typeof(object));
+                t.Rows.Add(new object[] { paramValue });
+                DataRow[] rowToSend = t.Select();
+                using (SqlBulkCopy bulkCopy = new(conn))
                 {
-                    conn.Open();
-                    DropTable(conn, bulkCopyTableName);
-                    xsql(conn, string.Format("create table {0} (f1 sql_variant)", bulkCopyTableName));
-
-                    DataTable t = new DataTable();
-                    t.Columns.Add("f1", typeof(object));
-                    t.Rows.Add(new object[] { paramValue });
-                    // Send using DataRow as source.
-                    DataRow[] rowToSend = t.Select();
-
-                    // Perform bulk copy to target.
-                    using (SqlBulkCopy bulkCopy = new SqlBulkCopy(conn))
-                    {
-                        bulkCopy.BulkCopyTimeout = 60;
-                        bulkCopy.BatchSize = 1;
-                        bulkCopy.DestinationTableName = bulkCopyTableName;
-                        bulkCopy.WriteToServer(rowToSend);
-                    }
-
-                    // Verify target.
-                    using (SqlCommand cmd = conn.CreateCommand())
-                    {
-                        cmd.CommandText = string.Format("select f1, sql_variant_property(f1,'BaseType') as BaseType from {0}", bulkCopyTableName);
-                        using (SqlDataReader drVerify = cmd.ExecuteReader())
-                        {
-                            drVerify.Read();
-                            VerifyReaderTypeAndValue("SqlBulkCopy From Data Row [Variant Type]", "SqlDbType.Variant", drVerify, expectedTypeName, expectedBaseTypeName, paramValue);
-                            drVerify.Dispose();
-                        }
-                    }
+                    bulkCopy.BulkCopyTimeout = 60;
+                    bulkCopy.BatchSize = 1;
+                    bulkCopy.DestinationTableName = bulkCopyTableName;
+                    bulkCopy.WriteToServer(rowToSend);
+                }
+                using SqlCommand cmd = conn.CreateCommand();
+                cmd.CommandText = string.Format("select f1, sql_variant_property(f1,'BaseType') as BaseType from {0}", bulkCopyTableName);
+                using (SqlDataReader drVerify = cmd.ExecuteReader())
+                {
+                    drVerify.Read();
+                    VerifyReaderTypeAndValue("SqlBulkCopy From Data Row [Variant Type]", "SqlDbType.Variant", drVerify, expectedTypeName, expectedBaseTypeName, paramValue);
                 }
             }
             catch (Exception e)
@@ -1114,11 +976,9 @@ private static void SqlBulkCopyDataRow_Variant(object paramValue, string expecte
             }
             finally
             {
-                using (SqlConnection conn = new SqlConnection(s_connStr))
-                {
-                    conn.Open();
-                    DropTable(conn, bulkCopyTableName);
-                }
+                using SqlConnection conn = new(s_connStr);
+                conn.Open();
+                DropTable(conn, bulkCopyTableName);
             }
         }
 
@@ -1126,32 +986,23 @@ private static void SqlBulkCopyDataRow_Variant(object paramValue, string expecte
 
         private static SqlDbType GetSqlDbType(string expectedBaseTypeName)
         {
-            switch (expectedBaseTypeName.ToLowerInvariant())
-            {
-                case "time":
-                    return SqlDbType.Time;
-                case "date":
-                    return SqlDbType.Date;
-                case "smalldatetime":
-                    return SqlDbType.SmallDateTime;
-                case "datetime":
-                    return SqlDbType.DateTime;
-                case "datetime2":
-                    return SqlDbType.DateTime2;
-                case "datetimeoffset":
-                    return SqlDbType.DateTimeOffset;
-                default:
-                    return SqlDbType.Variant;
-            }
+            return expectedBaseTypeName.ToLowerInvariant() switch
+            {
+                "time" => SqlDbType.Time,
+                "date" => SqlDbType.Date,
+                "smalldatetime" => SqlDbType.SmallDateTime,
+                "datetime" => SqlDbType.DateTime,
+                "datetime2" => SqlDbType.DateTime2,
+                "datetimeoffset" => SqlDbType.DateTimeOffset,
+                _ => SqlDbType.Variant,
+            };
         }
 
         private static void xsql(SqlConnection conn, string sql)
         {
-            using (SqlCommand cmd = conn.CreateCommand())
-            {
-                cmd.CommandText = sql;
-                cmd.ExecuteNonQuery();
-            }
+            using SqlCommand cmd = conn.CreateCommand();
+            cmd.CommandText = sql;
+            cmd.ExecuteNonQuery();
         }
 
         private static void DropStoredProcedure(SqlConnection conn, string procName)
@@ -1186,7 +1037,7 @@ private static void VerifyReaderTypeAndValue(string tag, string expectedBaseType
             }
             if (!actualValue.Equals(expectedValue))
             {
-                string ErrorMessage = string.Empty;
+                string ErrorMessage;
                 if (IsValueCorrectForType(expectedBaseTypeName, expectedValue, actualValue))
                 {
                     ErrorMessage = string.Format("[EXPECTED ERROR]: VALUE MISMATCH - [Actual = {0}] [Expected = {1}]",
@@ -1231,7 +1082,7 @@ private static void VerifyReaderTypeAndValue(string tag, string type, SqlDataRea
             }
             if (!actualValue.Equals(expectedValue))
             {
-                string ErrorMessage = string.Empty;
+                string ErrorMessage;
                 if (IsValueCorrectForType(expectedBaseTypeName, expectedValue, actualValue))
                 {
                     ErrorMessage = string.Format("[EXPECTED ERROR]: VALUE MISMATCH - [Actual = {0}] [Expected = {1}]",
@@ -1253,13 +1104,13 @@ private static bool IsValueCorrectForType(string expectedBaseTypeName, object ex
             switch (expectedBaseTypeName)
             {
                 case "date":
-                    if (((System.DateTime)expectedValue).ToString("M/d/yyyy").Equals(((System.DateTime)actualValue).ToString("M/d/yyyy")))
+                    if (((DateTime)expectedValue).ToString("M/d/yyyy").Equals(((DateTime)actualValue).ToString("M/d/yyyy")))
                         return true;
                     else
                         return false;
                 case "datetime":
-                    if ((((System.DateTime)expectedValue).Ticks == 3155378975999999999) &&
-                        (((System.DateTime)actualValue).Ticks == 3155378975999970000))
+                    if ((((DateTime)expectedValue).Ticks == 3155378975999999999) &&
+                        (((DateTime)actualValue).Ticks == 3155378975999970000))
                         return true;
                     else
                         return false;
@@ -1306,19 +1157,19 @@ private static bool IsExpectedInvalidOperationException(Exception e, string expe
 
         private static string AmendTheGivenMessageDateValueException(string message, object paramValue)
         {
-            string value = string.Empty;
-            if (paramValue.GetType() == typeof(System.DateTimeOffset))
+            string value;
+            if (paramValue.GetType() == typeof(DateTimeOffset))
             {
-                DateTime dt = ((System.DateTimeOffset)paramValue).UtcDateTime;
+                DateTime dt = ((DateTimeOffset)paramValue).UtcDateTime;
                 value = dt.ToString("M/d/yyyy") + " " + dt.TimeOfDay;
             }
-            else if (paramValue.GetType() == typeof(System.TimeSpan))
+            else if (paramValue.GetType() == typeof(TimeSpan))
             {
-                value = ((System.TimeSpan)paramValue).ToString();
+                value = ((TimeSpan)paramValue).ToString();
             }
             else
             {
-                value = ((System.DateTime)paramValue).ToString("M/d/yyyy") + " " + ((System.DateTime)paramValue).TimeOfDay;
+                value = ((DateTime)paramValue).ToString("M/d/yyyy") + " " + ((DateTime)paramValue).TimeOfDay;
             }
 
             return message.Replace(paramValue.ToString(), value);
@@ -1328,19 +1179,19 @@ private static string AmendTheGivenMessageDateValueException(string message, obj
         private static void DisplayHeader(string tag, object paramValue, string expectedBaseTypeName)
         {
             Console.WriteLine("");
-            string value = string.Empty;
-            if (paramValue.GetType() == typeof(System.DateTimeOffset))
+            string value;
+            if (paramValue.GetType() == typeof(DateTimeOffset))
             {
-                System.DateTimeOffset dt = (System.DateTimeOffset)paramValue;
+                DateTimeOffset dt = (DateTimeOffset)paramValue;
                 value = dt.DateTime.ToString("M/d/yyyy") + " " + dt.DateTime.TimeOfDay + " " + dt.Offset;
             }
-            else if (paramValue.GetType() == typeof(System.TimeSpan))
+            else if (paramValue.GetType() == typeof(TimeSpan))
             {
-                value = ((System.TimeSpan)paramValue).ToString();
+                value = ((TimeSpan)paramValue).ToString();
             }
             else
             {
-                value = ((System.DateTime)paramValue).ToString("M/d/yyyy") + " " + ((System.DateTime)paramValue).TimeOfDay;
+                value = ((DateTime)paramValue).ToString("M/d/yyyy") + " " + ((DateTime)paramValue).TimeOfDay;
             }
 
             Console.WriteLine(string.Format("------------------------------ {0} [type: {1} value:{2}] ------------------------------", tag, expectedBaseTypeName, value));
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/OutputParameter.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/OutputParameter.cs
index 8d81e13ec9..6af1a39e1d 100644
--- a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/OutputParameter.cs
+++ b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/OutputParameter.cs
@@ -26,22 +26,20 @@ private static void InvalidValueInOutParam(string connectionString)
                 connection.Open();
 
                 // Command simply set the outparam
-                using (var command = new SqlCommand("SET @decimal = 1.23", connection))
+                using var command = new SqlCommand("SET @decimal = 1.23", connection);
+
+                // Create valid param
+                var decimalParam = new SqlParameter("decimal", new decimal(2.34)) { SqlDbType = SqlDbType.Decimal, Direction = ParameterDirection.Output, Scale = 2, Precision = 5 };
+                command.Parameters.Add(decimalParam);
+                // Set value of param to invalid value
+                decimalParam.Value = "Not a decimal";
+
+                // Execute
+                command.ExecuteNonQuery();
+                // Validate
+                if (((decimal)decimalParam.Value) != new decimal(1.23))
                 {
-
-                    // Create valid param
-                    var decimalParam = new SqlParameter("decimal", new decimal(2.34)) { SqlDbType = SqlDbType.Decimal, Direction = ParameterDirection.Output, Scale = 2, Precision = 5 };
-                    command.Parameters.Add(decimalParam);
-                    // Set value of param to invalid value
-                    decimalParam.Value = "Not a decimal";
-
-                    // Execute
-                    command.ExecuteNonQuery();
-                    // Validate
-                    if (((decimal)decimalParam.Value) != new decimal(1.23))
-                    {
-                        Console.WriteLine("FAIL: Value is incorrect: {0}", decimalParam.Value);
-                    }
+                    Console.WriteLine("FAIL: Value is incorrect: {0}", decimalParam.Value);
                 }
             }
 
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/ParametersTest.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/ParametersTest.cs
index af54b4a4cc..fe0f1eb4a9 100644
--- a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/ParametersTest.cs
+++ b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/ParametersTest.cs
@@ -14,7 +14,7 @@ namespace Microsoft.Data.SqlClient.ManualTesting.Tests
 {
     public static class ParametersTest
     {
-        private static string s_connString = DataTestUtility.TCPConnectionString;
+        private static readonly string s_connString = DataTestUtility.TCPConnectionString;
 
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
         public static void CodeCoverageSqlClient()
@@ -108,50 +108,49 @@ public static void CodeCoverageSqlClient()
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureSynapse))]
         public static void Test_Copy_SqlParameter()
         {
-            using (var conn = new SqlConnection(s_connString))
+            using var conn = new SqlConnection(s_connString);
+            string cTableName = DataTestUtility.GetUniqueNameForSqlServer("#tmp");
+            try
             {
-                string cTableName = DataTestUtility.GetUniqueNameForSqlServer("#tmp");
-                try
-                {
-                    // Create tmp table
-                    var sCreateTable = "IF NOT EXISTS(";
-                    sCreateTable += $"SELECT * FROM sysobjects WHERE name= '{ cTableName }' and xtype = 'U')";
-                    sCreateTable += $"CREATE TABLE { cTableName }( BinValue binary(16)  null)";
-
-                    conn.Open();
-                    var cmd = new SqlCommand(sCreateTable, conn);
-                    cmd.ExecuteNonQuery();
+                // Create tmp table
+                var sCreateTable = "IF NOT EXISTS(";
+                sCreateTable += $"SELECT * FROM sysobjects WHERE name= '{ cTableName }' and xtype = 'U')";
+                sCreateTable += $"CREATE TABLE { cTableName }( BinValue binary(16)  null)";
 
-                    var dt = new DataTable("SourceDataTable");
-                    dt.Columns.Add("SourceBinValue", typeof(byte[]));
+                conn.Open();
+                var cmd = new SqlCommand(sCreateTable, conn);
+                cmd.ExecuteNonQuery();
 
-                    dt.Rows.Add(Guid.NewGuid().ToByteArray());
-                    dt.Rows.Add(DBNull.Value);
+                var dt = new DataTable("SourceDataTable");
+                dt.Columns.Add("SourceBinValue", typeof(byte[]));
 
-                    var cmdInsert = new SqlCommand();
-                    cmdInsert.UpdatedRowSource = UpdateRowSource.None;
-                    cmdInsert.Connection = conn;
+                dt.Rows.Add(Guid.NewGuid().ToByteArray());
+                dt.Rows.Add(DBNull.Value);
 
-                    cmdInsert.CommandText = $"INSERT { cTableName } (BinValue) ";
-                    cmdInsert.CommandText += "Values(@BinValue)";
-                    cmdInsert.Parameters.Add("@BinValue", SqlDbType.Binary, 16, "SourceBinValue");
+                var cmdInsert = new SqlCommand
+                {
+                    UpdatedRowSource = UpdateRowSource.None,
+                    Connection = conn,
 
-                    var da = new SqlDataAdapter();
+                    CommandText = $"INSERT { cTableName } (BinValue) "
+                };
+                cmdInsert.CommandText += "Values(@BinValue)";
+                cmdInsert.Parameters.Add("@BinValue", SqlDbType.Binary, 16, "SourceBinValue");
 
-                    da.InsertCommand = cmdInsert;
-                    da.UpdateBatchSize = 2;
-                    da.AcceptChangesDuringUpdate = false;
-                    da.Update(dt);
-                }
-                finally
+                var da = new SqlDataAdapter
                 {
-                    // End of test, cleanup tmp table;
-                    var sDropTable = $"DROP TABLE IF EXISTS {cTableName}";
-                    using (SqlCommand cmd = new SqlCommand(sDropTable, conn))
-                    {
-                        cmd.ExecuteNonQuery();
-                    }
-                }
+                    InsertCommand = cmdInsert,
+                    UpdateBatchSize = 2,
+                    AcceptChangesDuringUpdate = false
+                };
+                da.Update(dt);
+            }
+            finally
+            {
+                // End of test, cleanup tmp table;
+                var sDropTable = $"DROP TABLE IF EXISTS {cTableName}";
+                using SqlCommand cmd = new(sDropTable, conn);
+                cmd.ExecuteNonQuery();
             }
         }
 
@@ -159,164 +158,150 @@ public static void Test_Copy_SqlParameter()
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureSynapse))]
         public static void Test_SqlParameter_Constructor()
         {
-            using (var conn = new SqlConnection(s_connString))
-            {
-                var dataTable = new DataTable();
-                var adapter = new SqlDataAdapter();
-
-                adapter.SelectCommand = new SqlCommand("SELECT CustomerID, ContactTitle FROM dbo.Customers WHERE ContactTitle = @ContactTitle", conn);
-                var selectParam = new SqlParameter("@ContactTitle", SqlDbType.NVarChar, 30, ParameterDirection.Input, true, 0, 0, "ContactTitle", DataRowVersion.Current, "Owner");
-                adapter.SelectCommand.Parameters.Add(selectParam);
-
-                adapter.UpdateCommand = new SqlCommand("UPDATE dbo.Customers SET ContactTitle = @ContactTitle WHERE CustomerID = @CustomerID", conn);
-                var titleParam = new SqlParameter("@ContactTitle", SqlDbType.NVarChar, 30, ParameterDirection.Input, true, 0, 0, "ContactTitle", DataRowVersion.Current, null);
-                var idParam = new SqlParameter("@CustomerID", SqlDbType.NChar, 5, ParameterDirection.Input, false, 0, 0, "CustomerID", DataRowVersion.Current, null);
-                adapter.UpdateCommand.Parameters.Add(titleParam);
-                adapter.UpdateCommand.Parameters.Add(idParam);
-
-                adapter.Fill(dataTable);
-                object titleData = dataTable.Rows[0]["ContactTitle"];
-                Assert.Equal("Owner", (string)titleData);
-
-                titleData = "Test Data";
-                adapter.Update(dataTable);
-                adapter.Fill(dataTable);
-                Assert.Equal("Test Data", (string)titleData);
-
-                titleData = "Owner";
-                adapter.Update(dataTable);
-            }
+            using var conn = new SqlConnection(s_connString);
+            var dataTable = new DataTable();
+            var adapter = new SqlDataAdapter
+            {
+                SelectCommand = new SqlCommand("SELECT CustomerID, ContactTitle FROM dbo.Customers WHERE ContactTitle = @ContactTitle", conn)
+            };
+            var selectParam = new SqlParameter("@ContactTitle", SqlDbType.NVarChar, 30, ParameterDirection.Input, true, 0, 0, "ContactTitle", DataRowVersion.Current, "Owner");
+            adapter.SelectCommand.Parameters.Add(selectParam);
+
+            adapter.UpdateCommand = new SqlCommand("UPDATE dbo.Customers SET ContactTitle = @ContactTitle WHERE CustomerID = @CustomerID", conn);
+            var titleParam = new SqlParameter("@ContactTitle", SqlDbType.NVarChar, 30, ParameterDirection.Input, true, 0, 0, "ContactTitle", DataRowVersion.Current, null);
+            var idParam = new SqlParameter("@CustomerID", SqlDbType.NChar, 5, ParameterDirection.Input, false, 0, 0, "CustomerID", DataRowVersion.Current, null);
+            adapter.UpdateCommand.Parameters.Add(titleParam);
+            adapter.UpdateCommand.Parameters.Add(idParam);
+
+            adapter.Fill(dataTable);
+            object titleData = dataTable.Rows[0]["ContactTitle"];
+            Assert.Equal("Owner", (string)titleData);
+
+            titleData = "Test Data";
+            adapter.Update(dataTable);
+            adapter.Fill(dataTable);
+            Assert.Equal("Test Data", (string)titleData);
+
+            titleData = "Owner";
+            adapter.Update(dataTable);
         }
 
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
         public static void Test_WithEnumValue_ShouldInferToUnderlyingType()
         {
-            using (var conn = new SqlConnection(s_connString))
-            {
-                conn.Open();
-                var cmd = new SqlCommand("select @input", conn);
-                cmd.Parameters.AddWithValue("@input", MyEnum.B);
-                object value = cmd.ExecuteScalar();
-                Assert.Equal(MyEnum.B, (MyEnum)value);
-            }
+            using var conn = new SqlConnection(s_connString);
+            conn.Open();
+            var cmd = new SqlCommand("select @input", conn);
+            cmd.Parameters.AddWithValue("@input", MyEnum.B);
+            object value = cmd.ExecuteScalar();
+            Assert.Equal(MyEnum.B, (MyEnum)value);
         }
 
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
         public static void Test_WithOutputEnumParameter_ShouldReturnEnum()
         {
-            using (var conn = new SqlConnection(s_connString))
-            {
-                conn.Open();
-                var cmd = new SqlCommand("set @output = @input", conn);
-                cmd.Parameters.AddWithValue("@input", MyEnum.B);
-
-                var outputParam = cmd.CreateParameter();
-                outputParam.ParameterName = "@output";
-                outputParam.DbType = DbType.Int32;
-                outputParam.Direction = ParameterDirection.Output;
-                cmd.Parameters.Add(outputParam);
-
-                cmd.ExecuteNonQuery();
-
-                Assert.Equal(MyEnum.B, (MyEnum)outputParam.Value);
-            }
+            using var conn = new SqlConnection(s_connString);
+            conn.Open();
+            var cmd = new SqlCommand("set @output = @input", conn);
+            cmd.Parameters.AddWithValue("@input", MyEnum.B);
+            SqlParameter outputParam = cmd.CreateParameter();
+            outputParam.ParameterName = "@output";
+            outputParam.DbType = DbType.Int32;
+            outputParam.Direction = ParameterDirection.Output;
+            cmd.Parameters.Add(outputParam);
+            cmd.ExecuteNonQuery();
+            Assert.Equal(MyEnum.B, (MyEnum)outputParam.Value);
         }
 
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
         public static void Test_WithDecimalValue_ShouldReturnDecimal()
         {
-            using (var conn = new SqlConnection(s_connString))
-            {
-                conn.Open();
-                var cmd = new SqlCommand("select @foo", conn);
-                cmd.Parameters.AddWithValue("@foo", new SqlDecimal(0.5));
-                var result = (decimal)cmd.ExecuteScalar();
-                Assert.Equal(result, (decimal)0.5);
-            }
+            using var conn = new SqlConnection(s_connString);
+            conn.Open();
+            var cmd = new SqlCommand("select @foo", conn);
+            cmd.Parameters.AddWithValue("@foo", new SqlDecimal(0.5));
+            var result = (decimal)cmd.ExecuteScalar();
+            Assert.Equal(result, (decimal)0.5);
         }
 
         // Synapse: Unsupported parameter type found while parsing RPC request. The request has been terminated.
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureSynapse))]
         public static void Test_WithGuidValue_ShouldReturnGuid()
         {
-            using (var conn = new SqlConnection(s_connString))
-            {
-                conn.Open();
-                var expectedGuid = Guid.NewGuid();
-                var cmd = new SqlCommand("select @input", conn);
-                cmd.Parameters.AddWithValue("@input", expectedGuid);
-                var result = cmd.ExecuteScalar();
-                Assert.Equal(expectedGuid, (Guid)result);
-            }
+            using var conn = new SqlConnection(s_connString);
+            conn.Open();
+            var expectedGuid = Guid.NewGuid();
+            var cmd = new SqlCommand("select @input", conn);
+            cmd.Parameters.AddWithValue("@input", expectedGuid);
+            var result = cmd.ExecuteScalar();
+            Assert.Equal(expectedGuid, (Guid)result);
         }
 
         // Synapse: Parse error at line: 1, column: 8: Incorrect syntax near 'TYPE'.
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureServer))]
         public static void TestParametersWithDatatablesTVPInsert()
         {
-            SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder(DataTestUtility.TCPConnectionString);
+            SqlConnectionStringBuilder builder = new(DataTestUtility.TCPConnectionString);
             int x = 4, y = 5;
 
-            DataTable table = new DataTable { Columns = { { "x", typeof(int) }, { "y", typeof(int) } }, Rows = { { x, y } } };
+            DataTable table = new()
+            {
+                Columns = { { "x", typeof(int) }, { "y", typeof(int) } },
+                Rows = { { x, y } }
+            };
 
-            using (SqlConnection connection = new SqlConnection(builder.ConnectionString))
+            using SqlConnection connection = new(builder.ConnectionString);
+            string tableName = DataTestUtility.GetUniqueNameForSqlServer("Table");
+            string procName = DataTestUtility.GetUniqueNameForSqlServer("Proc");
+            string typeName = DataTestUtility.GetUniqueName("Type");
+            try
             {
-                string tableName = DataTestUtility.GetUniqueNameForSqlServer("Table");
-                string procName = DataTestUtility.GetUniqueNameForSqlServer("Proc");
-                string typeName = DataTestUtility.GetUniqueName("Type");
-                try
+                connection.Open();
+                using (SqlCommand cmd = connection.CreateCommand())
                 {
-                    connection.Open();
-                    using (SqlCommand cmd = connection.CreateCommand())
-                    {
-                        cmd.CommandText = $"CREATE TYPE {typeName} AS TABLE (x INT, y INT)";
-                        cmd.ExecuteNonQuery();
+                    cmd.CommandText = $"CREATE TYPE {typeName} AS TABLE (x INT, y INT)";
+                    cmd.ExecuteNonQuery();
 
-                        cmd.CommandText = $"CREATE TABLE {tableName} (x INT, y INT)";
-                        cmd.ExecuteNonQuery();
+                    cmd.CommandText = $"CREATE TABLE {tableName} (x INT, y INT)";
+                    cmd.ExecuteNonQuery();
 
-                        cmd.CommandText = $"CREATE PROCEDURE {procName} @TVP {typeName} READONLY AS " +
-                            $"SET NOCOUNT ON INSERT INTO {tableName}(x, y) SELECT * FROM  @TVP";
-                        cmd.ExecuteNonQuery();
+                    cmd.CommandText = $"CREATE PROCEDURE {procName} @TVP {typeName} READONLY AS " +
+                        $"SET NOCOUNT ON INSERT INTO {tableName}(x, y) SELECT * FROM  @TVP";
+                    cmd.ExecuteNonQuery();
 
-                    }
-                    using (SqlCommand cmd = connection.CreateCommand())
-                    {
-                        // Update Data Using TVPs
-                        cmd.CommandText = procName;
-                        cmd.CommandType = CommandType.StoredProcedure;
+                }
+                using (SqlCommand cmd = connection.CreateCommand())
+                {
+                    // Update Data Using TVPs
+                    cmd.CommandText = procName;
+                    cmd.CommandType = CommandType.StoredProcedure;
 
-                        SqlParameter parameter = cmd.Parameters.AddWithValue("@TVP", table);
-                        parameter.TypeName = typeName;
+                    SqlParameter parameter = cmd.Parameters.AddWithValue("@TVP", table);
+                    parameter.TypeName = typeName;
 
-                        cmd.ExecuteNonQuery();
+                    cmd.ExecuteNonQuery();
 
-                        // Verify if the data was updated 
-                        cmd.CommandText = "select * from " + tableName;
-                        cmd.CommandType = CommandType.Text;
-                        using (SqlDataReader reader = cmd.ExecuteReader())
-                        {
-                            DataTable dbData = new DataTable();
-                            dbData.Load(reader);
-                            Assert.Equal(1, dbData.Rows.Count);
-                            Assert.Equal(x, dbData.Rows[0][0]);
-                            Assert.Equal(y, dbData.Rows[0][1]);
-                        }
-                    }
-                }
-                finally
-                {
-                    using (SqlCommand cmd = connection.CreateCommand())
-                    {
-                        cmd.CommandText = "DROP PROCEDURE " + procName;
-                        cmd.ExecuteNonQuery();
-                        cmd.CommandText = "DROP TABLE " + tableName;
-                        cmd.ExecuteNonQuery();
-                        cmd.CommandText = "DROP TYPE " + typeName;
-                        cmd.ExecuteNonQuery();
-                    }
+                    // Verify if the data was updated 
+                    cmd.CommandText = "select * from " + tableName;
+                    cmd.CommandType = CommandType.Text;
+                    using SqlDataReader reader = cmd.ExecuteReader();
+                    DataTable dbData = new();
+                    dbData.Load(reader);
+                    Assert.Equal(1, dbData.Rows.Count);
+                    Assert.Equal(x, dbData.Rows[0][0]);
+                    Assert.Equal(y, dbData.Rows[0][1]);
                 }
             }
+            finally
+            {
+                using SqlCommand cmd = connection.CreateCommand();
+                cmd.CommandText = "DROP PROCEDURE " + procName;
+                cmd.ExecuteNonQuery();
+                cmd.CommandText = "DROP TABLE " + tableName;
+                cmd.ExecuteNonQuery();
+                cmd.CommandText = "DROP TYPE " + typeName;
+                cmd.ExecuteNonQuery();
+            }
         }
 
         #region Scaled Decimal Parameter & TVP Test
@@ -340,20 +325,14 @@ public static void TestParametersWithDatatablesTVPInsert()
         [InlineData("CAST(-0.0000000000000000000000000001 as decimal(38, 38))", "-0.0000000000000000000000000001")]
         public static void SqlDecimalConvertToDecimal_TestInRange(string sqlDecimalValue, string expectedDecimalValue)
         {
-            using (SqlConnection cnn = new(s_connString))
-            {
-                cnn.Open();
-                using (SqlCommand cmd = new($"SELECT {sqlDecimalValue} val"))
-                {
-                    cmd.Connection = cnn;
-                    using (SqlDataReader rdr = cmd.ExecuteReader())
-                    {
-                        Assert.True(rdr.Read(), "SqlDataReader must have a value");
-                        decimal retrunValue = rdr.GetDecimal(0);
-                        Assert.Equal(expectedDecimalValue, retrunValue.ToString());
-                    }
-                }
-            }
+            using SqlConnection cnn = new(s_connString);
+            cnn.Open();
+            using SqlCommand cmd = new($"SELECT {sqlDecimalValue} val");
+            cmd.Connection = cnn;
+            using SqlDataReader rdr = cmd.ExecuteReader();
+            Assert.True(rdr.Read(), "SqlDataReader must have a value");
+            decimal retrunValue = rdr.GetDecimal(0);
+            Assert.Equal(expectedDecimalValue, retrunValue.ToString());
         }
 
         [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
@@ -366,19 +345,13 @@ public static void SqlDecimalConvertToDecimal_TestInRange(string sqlDecimalValue
         [InlineData("CAST(0.123456789012345678901234567890 as decimal(38, 36))")]
         public static void SqlDecimalConvertToDecimal_TestOutOfRange(string sqlDecimalValue)
         {
-            using (SqlConnection cnn = new(s_connString))
-            {
-                cnn.Open();
-                using (SqlCommand cmd = new($"SELECT {sqlDecimalValue} val"))
-                {
-                    cmd.Connection = cnn;
-                    using (SqlDataReader rdr = cmd.ExecuteReader())
-                    {
-                        Assert.True(rdr.Read(), "SqlDataReader must have a value");
-                        Assert.Throws<OverflowException>(() => rdr.GetDecimal(0));
-                    }
-                }
-            }
+            using SqlConnection cnn = new(s_connString);
+            cnn.Open();
+            using SqlCommand cmd = new($"SELECT {sqlDecimalValue} val");
+            cmd.Connection = cnn;
+            using SqlDataReader rdr = cmd.ExecuteReader();
+            Assert.True(rdr.Read(), "SqlDataReader must have a value");
+            Assert.Throws<OverflowException>(() => rdr.GetDecimal(0));
         }
 
         [Theory]
@@ -386,30 +359,30 @@ public static void SqlDecimalConvertToDecimal_TestOutOfRange(string sqlDecimalVa
         public static void TestScaledDecimalParameter_CommandInsert(string connectionString, bool truncateScaledDecimal)
         {
             string tableName = DataTestUtility.GetUniqueNameForSqlServer("TestDecimalParameterCMD");
-            using (SqlConnection connection = InitialDatabaseTable(connectionString, tableName))
+            using SqlConnection connection = InitialDatabaseTable(connectionString, tableName);
+            try
             {
-                try
+                using (SqlCommand cmd = connection.CreateCommand())
                 {
-                    using (SqlCommand cmd = connection.CreateCommand())
+                    AppContext.SetSwitch(TruncateDecimalSwitch, truncateScaledDecimal);
+                    var p = new SqlParameter("@Value", null)
                     {
-                        AppContext.SetSwitch(truncateDecimalSwitch, truncateScaledDecimal);
-                        var p = new SqlParameter("@Value", null);
-                        p.Precision = 18;
-                        p.Scale = 2;
-                        cmd.Parameters.Add(p);
-                        for (int i = 0; i < _testValues.Length; i++)
-                        {
-                            p.Value = _testValues[i];
-                            cmd.CommandText = $"INSERT INTO {tableName} (Id, [Value]) VALUES({i}, @Value)";
-                            cmd.ExecuteNonQuery();
-                        }
+                        Precision = 18,
+                        Scale = 2
+                    };
+                    cmd.Parameters.Add(p);
+                    for (int i = 0; i < s_testValues.Length; i++)
+                    {
+                        p.Value = s_testValues[i];
+                        cmd.CommandText = $"INSERT INTO {tableName} (Id, [Value]) VALUES({i}, @Value)";
+                        cmd.ExecuteNonQuery();
                     }
-                    Assert.True(ValidateInsertedValues(connection, tableName, truncateScaledDecimal), $"Invalid test happened with connection string [{connection.ConnectionString}]");
-                }
-                finally
-                {
-                    DataTestUtility.DropTable(connection, tableName);
                 }
+                Assert.True(ValidateInsertedValues(connection, tableName, truncateScaledDecimal), $"Invalid test happened with connection string [{connection.ConnectionString}]");
+            }
+            finally
+            {
+                DataTestUtility.DropTable(connection, tableName);
             }
         }
 
@@ -418,33 +391,31 @@ public static void TestScaledDecimalParameter_CommandInsert(string connectionStr
         public static void TestScaledDecimalParameter_BulkCopy(string connectionString, bool truncateScaledDecimal)
         {
             string tableName = DataTestUtility.GetUniqueNameForSqlServer("TestDecimalParameterBC");
-            using (SqlConnection connection = InitialDatabaseTable(connectionString, tableName))
+            using SqlConnection connection = InitialDatabaseTable(connectionString, tableName);
+            try
             {
-                try
+                using (SqlBulkCopy bulkCopy = new(connection))
                 {
-                    using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connection))
+                    DataTable table = new(tableName);
+                    table.Columns.Add("Id", typeof(int));
+                    table.Columns.Add("Value", typeof(decimal));
+                    for (int i = 0; i < s_testValues.Length; i++)
                     {
-                        DataTable table = new DataTable(tableName);
-                        table.Columns.Add("Id", typeof(int));
-                        table.Columns.Add("Value", typeof(decimal));
-                        for (int i = 0; i < _testValues.Length; i++)
-                        {
-                            var newRow = table.NewRow();
-                            newRow["Id"] = i;
-                            newRow["Value"] = _testValues[i];
-                            table.Rows.Add(newRow);
-                        }
-
-                        bulkCopy.DestinationTableName = tableName;
-                        AppContext.SetSwitch(truncateDecimalSwitch, truncateScaledDecimal);
-                        bulkCopy.WriteToServer(table);
+                        DataRow newRow = table.NewRow();
+                        newRow["Id"] = i;
+                        newRow["Value"] = s_testValues[i];
+                        table.Rows.Add(newRow);
                     }
-                    Assert.True(ValidateInsertedValues(connection, tableName, truncateScaledDecimal), $"Invalid test happened with connection string [{connection.ConnectionString}]");
-                }
-                finally
-                {
-                    DataTestUtility.DropTable(connection, tableName);
+
+                    bulkCopy.DestinationTableName = tableName;
+                    AppContext.SetSwitch(TruncateDecimalSwitch, truncateScaledDecimal);
+                    bulkCopy.WriteToServer(table);
                 }
+                Assert.True(ValidateInsertedValues(connection, tableName, truncateScaledDecimal), $"Invalid test happened with connection string [{connection.ConnectionString}]");
+            }
+            finally
+            {
+                DataTestUtility.DropTable(connection, tableName);
             }
         }
 
@@ -456,53 +427,53 @@ public static void TestScaledDecimalTVP_CommandSP(string connectionString, bool
             string tableName = DataTestUtility.GetUniqueNameForSqlServer("TestDecimalParameterBC");
             string tableTypeName = DataTestUtility.GetUniqueNameForSqlServer("UDTTTestDecimalParameterBC");
             string spName = DataTestUtility.GetUniqueNameForSqlServer("spTestDecimalParameterBC");
-            using (SqlConnection connection = InitialDatabaseUDTT(connectionString, tableName, tableTypeName, spName))
+            using SqlConnection connection = InitialDatabaseUDTT(connectionString, tableName, tableTypeName, spName);
+            try
             {
-                try
+                using (SqlCommand cmd = connection.CreateCommand())
                 {
-                    using (SqlCommand cmd = connection.CreateCommand())
+                    var p = new SqlParameter("@tvp", SqlDbType.Structured)
                     {
-                        var p = new SqlParameter("@tvp", SqlDbType.Structured);
-                        p.TypeName = $"dbo.{tableTypeName}";
-                        cmd.CommandText = spName;
-                        cmd.CommandType = CommandType.StoredProcedure;
-                        cmd.Parameters.Add(p);
-
-                        DataTable table = new DataTable(tableName);
-                        table.Columns.Add("Id", typeof(int));
-                        table.Columns.Add("Value", typeof(decimal));
-                        for (int i = 0; i < _testValues.Length; i++)
-                        {
-                            var newRow = table.NewRow();
-                            newRow["Id"] = i;
-                            newRow["Value"] = _testValues[i];
-                            table.Rows.Add(newRow);
-                        }
-                        p.Value = table;
-                        AppContext.SetSwitch(truncateDecimalSwitch, truncateScaledDecimal);
-                        cmd.ExecuteNonQuery();
+                        TypeName = $"dbo.{tableTypeName}"
+                    };
+                    cmd.CommandText = spName;
+                    cmd.CommandType = CommandType.StoredProcedure;
+                    cmd.Parameters.Add(p);
+
+                    DataTable table = new(tableName);
+                    table.Columns.Add("Id", typeof(int));
+                    table.Columns.Add("Value", typeof(decimal));
+                    for (int i = 0; i < s_testValues.Length; i++)
+                    {
+                        DataRow newRow = table.NewRow();
+                        newRow["Id"] = i;
+                        newRow["Value"] = s_testValues[i];
+                        table.Rows.Add(newRow);
                     }
-                    // TVP always rounds data without attention to the configuration.
-                    Assert.True(ValidateInsertedValues(connection, tableName, false && truncateScaledDecimal), $"Invalid test happened with connection string [{connection.ConnectionString}]");
-                }
-                finally
-                {
-                    DataTestUtility.DropTable(connection, tableName);
-                    DataTestUtility.DropStoredProcedure(connection, spName);
-                    DataTestUtility.DropUserDefinedType(connection, tableTypeName);
+                    p.Value = table;
+                    AppContext.SetSwitch(TruncateDecimalSwitch, truncateScaledDecimal);
+                    cmd.ExecuteNonQuery();
                 }
+                // TVP always rounds data without attention to the configuration.
+                Assert.True(ValidateInsertedValues(connection, tableName, false && truncateScaledDecimal), $"Invalid test happened with connection string [{connection.ConnectionString}]");
+            }
+            finally
+            {
+                DataTestUtility.DropTable(connection, tableName);
+                DataTestUtility.DropStoredProcedure(connection, spName);
+                DataTestUtility.DropUserDefinedType(connection, tableTypeName);
             }
         }
 
         #region Decimal parameter test setup
-        private static readonly decimal[] _testValues = new[] { 4210862852.8600000000_0000000000m, 19.1560m, 19.1550m, 19.1549m };
-        private static readonly decimal[] _expectedRoundedValues = new[] { 4210862852.86m, 19.16m, 19.16m, 19.15m };
-        private static readonly decimal[] _expectedTruncatedValues = new[] { 4210862852.86m, 19.15m, 19.15m, 19.15m };
-        private const string truncateDecimalSwitch = "Switch.Microsoft.Data.SqlClient.TruncateScaledDecimal";
+        private static readonly decimal[] s_testValues = new[] { 4210862852.8600000000_0000000000m, 19.1560m, 19.1550m, 19.1549m };
+        private static readonly decimal[] s_expectedRoundedValues = new[] { 4210862852.86m, 19.16m, 19.16m, 19.15m };
+        private static readonly decimal[] s_expectedTruncatedValues = new[] { 4210862852.86m, 19.15m, 19.15m, 19.15m };
+        private const string TruncateDecimalSwitch = "Switch.Microsoft.Data.SqlClient.TruncateScaledDecimal";
 
         private static SqlConnection InitialDatabaseUDTT(string cnnString, string tableName, string tableTypeName, string spName)
         {
-            SqlConnection connection = new SqlConnection(cnnString);
+            SqlConnection connection = new(cnnString);
             connection.Open();
             using (SqlCommand cmd = connection.CreateCommand())
             {
@@ -518,7 +489,7 @@ private static SqlConnection InitialDatabaseUDTT(string cnnString, string tableN
 
         private static SqlConnection InitialDatabaseTable(string cnnString, string tableName)
         {
-            SqlConnection connection = new SqlConnection(cnnString);
+            SqlConnection connection = new(cnnString);
             connection.Open();
             using (SqlCommand cmd = connection.CreateCommand())
             {
@@ -532,7 +503,7 @@ private static SqlConnection InitialDatabaseTable(string cnnString, string table
         private static bool ValidateInsertedValues(SqlConnection connection, string tableName, bool truncateScaledDecimal)
         {
             bool exceptionHit;
-            decimal[] expectedValues = truncateScaledDecimal ? _expectedTruncatedValues : _expectedRoundedValues;
+            decimal[] expectedValues = truncateScaledDecimal ? s_expectedTruncatedValues : s_expectedRoundedValues;
 
             try
             {
@@ -541,15 +512,13 @@ private static bool ValidateInsertedValues(SqlConnection connection, string tabl
                     // Verify if the data was as same as our expectation.
                     cmd.CommandText = $"SELECT [Value] FROM {tableName} ORDER BY Id ASC";
                     cmd.CommandType = CommandType.Text;
-                    using (SqlDataReader reader = cmd.ExecuteReader())
+                    using SqlDataReader reader = cmd.ExecuteReader();
+                    DataTable dbData = new();
+                    dbData.Load(reader);
+                    Assert.Equal(expectedValues.Length, dbData.Rows.Count);
+                    for (int i = 0; i < expectedValues.Length; i++)
                     {
-                        DataTable dbData = new DataTable();
-                        dbData.Load(reader);
-                        Assert.Equal(expectedValues.Length, dbData.Rows.Count);
-                        for (int i = 0; i < expectedValues.Length; i++)
-                        {
-                            Assert.Equal(expectedValues[i], dbData.Rows[i][0]);
-                        }
+                        Assert.Equal(expectedValues[i], dbData.Rows[i][0]);
                     }
                 }
                 exceptionHit = false;
@@ -585,13 +554,11 @@ private enum MyEnum
 
         private static void ExecuteNonQueryCommand(string connectionString, string cmdText)
         {
-            using (SqlConnection conn = new SqlConnection(connectionString))
-            using (SqlCommand cmd = conn.CreateCommand())
-            {
-                conn.Open();
-                cmd.CommandText = cmdText;
-                cmd.ExecuteNonQuery();
-            }
+            using SqlConnection conn = new(connectionString);
+            using SqlCommand cmd = conn.CreateCommand();
+            conn.Open();
+            cmd.CommandText = cmdText;
+            cmd.ExecuteNonQuery();
         }
 
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
@@ -599,86 +566,72 @@ private static void EnableOptimizedParameterBinding_ParametersAreUsedByName()
         {
             int firstInput = 1;
             int secondInput = 2;
-            using (var connection = new SqlConnection(DataTestUtility.TCPConnectionString))
-            {
-                connection.Open();
+            using var connection = new SqlConnection(DataTestUtility.TCPConnectionString);
+            connection.Open();
 
-                using (var command = new SqlCommand("SELECT @Second, @First", connection))
-                {
-                    command.EnableOptimizedParameterBinding = true;
-                    command.Parameters.AddWithValue("@First", firstInput);
-                    command.Parameters.AddWithValue("@Second", secondInput);
+            using var command = new SqlCommand("SELECT @Second, @First", connection);
+            command.EnableOptimizedParameterBinding = true;
+            command.Parameters.AddWithValue("@First", firstInput);
+            command.Parameters.AddWithValue("@Second", secondInput);
 
-                    using (SqlDataReader reader = command.ExecuteReader())
-                    {
-                        reader.Read();
+            using SqlDataReader reader = command.ExecuteReader();
+            reader.Read();
 
-                        int firstOutput = reader.GetInt32(0);
-                        int secondOutput = reader.GetInt32(1);
+            int firstOutput = reader.GetInt32(0);
+            int secondOutput = reader.GetInt32(1);
 
-                        Assert.Equal(firstInput, secondOutput);
-                        Assert.Equal(secondInput, firstOutput);
-                    }
-                }
-            }
+            Assert.Equal(firstInput, secondOutput);
+            Assert.Equal(secondInput, firstOutput);
         }
 
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
         private static void EnableOptimizedParameterBinding_NamesMustMatch()
         {
-            using (var connection = new SqlConnection(DataTestUtility.TCPConnectionString))
-            {
-                connection.Open();
-
-                using (var command = new SqlCommand("SELECT @DoesNotExist", connection))
-                {
-                    command.EnableOptimizedParameterBinding = true;
-                    command.Parameters.AddWithValue("@Exists", 1);
+            using var connection = new SqlConnection(DataTestUtility.TCPConnectionString);
+            connection.Open();
 
-                    SqlException sqlException = null;
-                    try
-                    {
-                        command.ExecuteNonQuery();
-                    }
-                    catch (SqlException sqlEx)
-                    {
-                        sqlException = sqlEx;
-                    }
+            using var command = new SqlCommand("SELECT @DoesNotExist", connection);
+            command.EnableOptimizedParameterBinding = true;
+            command.Parameters.AddWithValue("@Exists", 1);
 
-                    Assert.NotNull(sqlException);
-                    Assert.Contains("Must declare the scalar variable", sqlException.Message);
-                    Assert.Contains("@DoesNotExist", sqlException.Message);
-                }
+            SqlException sqlException = null;
+            try
+            {
+                command.ExecuteNonQuery();
             }
+            catch (SqlException sqlEx)
+            {
+                sqlException = sqlEx;
+            }
+
+            Assert.NotNull(sqlException);
+            Assert.Contains("Must declare the scalar variable", sqlException.Message);
+            Assert.Contains("@DoesNotExist", sqlException.Message);
         }
 
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
         private static void EnableOptimizedParameterBinding_AllNamesMustBeDeclared()
         {
-            using (var connection = new SqlConnection(DataTestUtility.TCPConnectionString))
-            {
-                connection.Open();
-
-                using (var command = new SqlCommand("SELECT @Exists, @DoesNotExist", connection))
-                {
-                    command.EnableOptimizedParameterBinding = true;
-                    command.Parameters.AddWithValue("@Exists", 1);
+            using var connection = new SqlConnection(DataTestUtility.TCPConnectionString);
+            connection.Open();
 
-                    SqlException sqlException = null;
-                    try
-                    {
-                        command.ExecuteNonQuery();
-                    }
-                    catch (SqlException sqlEx)
-                    {
-                        sqlException = sqlEx;
-                    }
+            using var command = new SqlCommand("SELECT @Exists, @DoesNotExist", connection);
+            command.EnableOptimizedParameterBinding = true;
+            command.Parameters.AddWithValue("@Exists", 1);
 
-                    Assert.NotNull(sqlException);
-                    Assert.Contains("Must declare the scalar variable", sqlException.Message);
-                    Assert.Contains("@DoesNotExist", sqlException.Message);
-                }
+            SqlException sqlException = null;
+            try
+            {
+                command.ExecuteNonQuery();
+            }
+            catch (SqlException sqlEx)
+            {
+                sqlException = sqlEx;
             }
+
+            Assert.NotNull(sqlException);
+            Assert.Contains("Must declare the scalar variable", sqlException.Message);
+            Assert.Contains("@DoesNotExist", sqlException.Message);
         }
 
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
@@ -688,31 +641,25 @@ private static void EnableOptimizedParameterBinding_NamesCanBeReUsed()
             int secondInput = 2;
             int thirdInput = 3;
 
-            using (var connection = new SqlConnection(DataTestUtility.TCPConnectionString))
-            {
-                connection.Open();
+            using var connection = new SqlConnection(DataTestUtility.TCPConnectionString);
+            connection.Open();
 
-                using (var command = new SqlCommand("SELECT @First, @Second, @First", connection))
-                {
-                    command.EnableOptimizedParameterBinding = true;
-                    command.Parameters.AddWithValue("@First", firstInput);
-                    command.Parameters.AddWithValue("@Second", secondInput);
-                    command.Parameters.AddWithValue("@Third", thirdInput);
+            using var command = new SqlCommand("SELECT @First, @Second, @First", connection);
+            command.EnableOptimizedParameterBinding = true;
+            command.Parameters.AddWithValue("@First", firstInput);
+            command.Parameters.AddWithValue("@Second", secondInput);
+            command.Parameters.AddWithValue("@Third", thirdInput);
 
-                    using (SqlDataReader reader = command.ExecuteReader())
-                    {
-                        reader.Read();
+            using SqlDataReader reader = command.ExecuteReader();
+            reader.Read();
 
-                        int firstOutput = reader.GetInt32(0);
-                        int secondOutput = reader.GetInt32(1);
-                        int thirdOutput = reader.GetInt32(2);
+            int firstOutput = reader.GetInt32(0);
+            int secondOutput = reader.GetInt32(1);
+            int thirdOutput = reader.GetInt32(2);
 
-                        Assert.Equal(firstInput, firstOutput);
-                        Assert.Equal(secondInput, secondOutput);
-                        Assert.Equal(firstInput, thirdOutput);
-                    }
-                }
-            }
+            Assert.Equal(firstInput, firstOutput);
+            Assert.Equal(secondInput, secondOutput);
+            Assert.Equal(firstInput, thirdOutput);
         }
 
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
@@ -722,23 +669,19 @@ private static void EnableOptimizedParameterBinding_InputOutputFails()
             int secondInput = 2;
             int thirdInput = 3;
 
-            using (var connection = new SqlConnection(DataTestUtility.TCPConnectionString))
-            {
-                connection.Open();
+            using var connection = new SqlConnection(DataTestUtility.TCPConnectionString);
+            connection.Open();
 
-                using (var command = new SqlCommand("SELECT @Third = (@Third + @First + @Second)", connection))
-                {
-                    command.EnableOptimizedParameterBinding = true;
-                    command.Parameters.AddWithValue("@First", firstInput);
-                    command.Parameters.AddWithValue("@Second", secondInput);
-                    SqlParameter thirdParameter = command.Parameters.AddWithValue("@Third", thirdInput);
-                    thirdParameter.Direction = ParameterDirection.InputOutput;
+            using var command = new SqlCommand("SELECT @Third = (@Third + @First + @Second)", connection);
+            command.EnableOptimizedParameterBinding = true;
+            command.Parameters.AddWithValue("@First", firstInput);
+            command.Parameters.AddWithValue("@Second", secondInput);
+            SqlParameter thirdParameter = command.Parameters.AddWithValue("@Third", thirdInput);
+            thirdParameter.Direction = ParameterDirection.InputOutput;
 
-                    InvalidOperationException exception = Assert.Throws<InvalidOperationException>(() => command.ExecuteNonQuery());
+            InvalidOperationException exception = Assert.Throws<InvalidOperationException>(() => command.ExecuteNonQuery());
 
-                    Assert.Contains("OptimizedParameterBinding", exception.Message);
-                }
-            }
+            Assert.Contains("OptimizedParameterBinding", exception.Message);
         }
 
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
@@ -748,23 +691,19 @@ private static void EnableOptimizedParameterBinding_OutputFails()
             int secondInput = 2;
             int thirdInput = 3;
 
-            using (var connection = new SqlConnection(DataTestUtility.TCPConnectionString))
-            {
-                connection.Open();
+            using var connection = new SqlConnection(DataTestUtility.TCPConnectionString);
+            connection.Open();
 
-                using (var command = new SqlCommand("SELECT @Third = (@Third + @First + @Second)", connection))
-                {
-                    command.EnableOptimizedParameterBinding = true;
-                    command.Parameters.AddWithValue("@First", firstInput);
-                    command.Parameters.AddWithValue("@Second", secondInput);
-                    SqlParameter thirdParameter = command.Parameters.AddWithValue("@Third", thirdInput);
-                    thirdParameter.Direction = ParameterDirection.Output;
+            using var command = new SqlCommand("SELECT @Third = (@Third + @First + @Second)", connection);
+            command.EnableOptimizedParameterBinding = true;
+            command.Parameters.AddWithValue("@First", firstInput);
+            command.Parameters.AddWithValue("@Second", secondInput);
+            SqlParameter thirdParameter = command.Parameters.AddWithValue("@Third", thirdInput);
+            thirdParameter.Direction = ParameterDirection.Output;
 
-                    InvalidOperationException exception = Assert.Throws<InvalidOperationException>(() => command.ExecuteNonQuery());
+            InvalidOperationException exception = Assert.Throws<InvalidOperationException>(() => command.ExecuteNonQuery());
 
-                    Assert.Contains("OptimizedParameterBinding", exception.Message);
-                }
-            }
+            Assert.Contains("OptimizedParameterBinding", exception.Message);
         }
 
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
@@ -785,22 +724,18 @@ private static void EnableOptimizedParameterBinding_ReturnSucceeds()
             {
                 ExecuteNonQueryCommand(DataTestUtility.TCPConnectionString, createSprocQuery);
 
-                using (var connection = new SqlConnection(DataTestUtility.TCPConnectionString))
-                {
-                    connection.Open();
+                using var connection = new SqlConnection(DataTestUtility.TCPConnectionString);
+                connection.Open();
 
-                    using (var command = new SqlCommand(sprocName, connection) { CommandType = CommandType.StoredProcedure })
-                    {
-                        command.EnableOptimizedParameterBinding = true;
-                        command.Parameters.AddWithValue("@in", firstInput);
-                        SqlParameter returnParameter = command.Parameters.AddWithValue("@retval", 0);
-                        returnParameter.Direction = ParameterDirection.ReturnValue;
+                using var command = new SqlCommand(sprocName, connection) { CommandType = CommandType.StoredProcedure };
+                command.EnableOptimizedParameterBinding = true;
+                command.Parameters.AddWithValue("@in", firstInput);
+                SqlParameter returnParameter = command.Parameters.AddWithValue("@retval", 0);
+                returnParameter.Direction = ParameterDirection.ReturnValue;
 
-                        command.ExecuteNonQuery();
+                command.ExecuteNonQuery();
 
-                        Assert.Equal(firstInput, Convert.ToInt32(returnParameter.Value));
-                    }
-                }
+                Assert.Equal(firstInput, Convert.ToInt32(returnParameter.Value));
             }
             finally
             {
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/SqlAdapterUpdateBatch.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/SqlAdapterUpdateBatch.cs
index 90d413a66d..7f383e8201 100644
--- a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/SqlAdapterUpdateBatch.cs
+++ b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/SqlAdapterUpdateBatch.cs
@@ -41,12 +41,10 @@ public void SqlAdapterTest()
             finally
             {
                 var dropTableQuery = "DROP TABLE IF EXISTS " + tableName;
-                using (var connection = new SqlConnection(DataTestUtility.TCPConnectionString))
-                using (var cmd = new SqlCommand(dropTableQuery, connection))
-                {
-                    connection.Open();
-                    cmd.ExecuteNonQuery();
-                }
+                using var connection = new SqlConnection(DataTestUtility.TCPConnectionString);
+                using var cmd = new SqlCommand(dropTableQuery, connection);
+                connection.Open();
+                cmd.ExecuteNonQuery();
             }
         }
 
@@ -65,29 +63,27 @@ public EventInfo()
 
         private static void ExecuteNonQueries(string tableName)
         {
-            List<EventInfo> entities = new List<EventInfo>
+            List<EventInfo> entities = new()
             {
-                new EventInfo {Level = "L1", Message = "Message 1"},
-                new EventInfo {Level = "L2", Message = "Message 2"},
-                new EventInfo {Level = "L3", Message = "Message 3"},
-                new EventInfo {Level = "L4", Message = "Message 4"},
+                new EventInfo { Level = "L1", Message = "Message 1" },
+                new EventInfo { Level = "L2", Message = "Message 2" },
+                new EventInfo { Level = "L3", Message = "Message 3" },
+                new EventInfo { Level = "L4", Message = "Message 4" },
             };
 
             var sql = "INSERT INTO " + tableName + "(Level, Message, EventTime)  VALUES(@Level, @Message, @EventTime)";
-            using (var connection = new SqlConnection(DataTestUtility.TCPConnectionString))
-            using (var adapter = new SqlDataAdapter())
-            using (var cmd = new SqlCommand(sql, connection))
-            {
-                cmd.Parameters.Add(new SqlParameter("@Level", System.Data.SqlDbType.NVarChar, 50, "Level"));
-                cmd.Parameters.Add(new SqlParameter("@Message", SqlDbType.NVarChar, 500, "Message"));
-                cmd.Parameters.Add(new SqlParameter("@EventTime", SqlDbType.DateTime, 0, "EventTime"));
-                cmd.UpdatedRowSource = UpdateRowSource.None;
+            using var connection = new SqlConnection(DataTestUtility.TCPConnectionString);
+            using var adapter = new SqlDataAdapter();
+            using var cmd = new SqlCommand(sql, connection);
+            cmd.Parameters.Add(new SqlParameter("@Level", System.Data.SqlDbType.NVarChar, 50, "Level"));
+            cmd.Parameters.Add(new SqlParameter("@Message", SqlDbType.NVarChar, 500, "Message"));
+            cmd.Parameters.Add(new SqlParameter("@EventTime", SqlDbType.DateTime, 0, "EventTime"));
+            cmd.UpdatedRowSource = UpdateRowSource.None;
 
-                adapter.InsertCommand = cmd;
-                adapter.UpdateBatchSize = 2;
+            adapter.InsertCommand = cmd;
+            adapter.UpdateBatchSize = 2;
 
-                adapter.Update(ConvertToTable(entities));
-            }
+            adapter.Update(ConvertToTable(entities));
         }
         private static DataTable ConvertToTable(List<EventInfo> entities)
         {
@@ -97,9 +93,9 @@ private static DataTable ConvertToTable(List<EventInfo> entities)
             table.Columns.Add("Message", typeof(string));
             table.Columns.Add("EventTime", typeof(DateTime));
 
-            foreach (var entity in entities)
+            foreach (EventInfo entity in entities)
             {
-                var row = table.NewRow();
+                DataRow row = table.NewRow();
                 row["Level"] = entity.Level;
                 row["Message"] = entity.Message;
                 row["EventTime"] = entity.EventTime;
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/SqlVariantParam.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/SqlVariantParam.cs
index f27e7d0b1e..2d11274191 100644
--- a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/SqlVariantParam.cs
+++ b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/SqlVariantParam.cs
@@ -46,7 +46,7 @@ public static void SendAllSqlTypesInsideVariant(string connStr)
         /// <returns></returns>
         private static SqlDataReader GetReaderForVariant(object paramValue, bool includeBaseType)
         {
-            SqlConnection conn = new SqlConnection(s_connStr);
+            SqlConnection conn = new(s_connStr);
             conn.Open();
             SqlCommand cmd = conn.CreateCommand();
             cmd.CommandText = "select @p1 as f1";
@@ -100,10 +100,8 @@ private static void SendVariant(object paramValue, string expectedTypeName, stri
         /// </summary>
         private static void SendVariantParam(object paramValue, string expectedTypeName, string expectedBaseTypeName)
         {
-            using (SqlDataReader dr = GetReaderForVariant(paramValue, true))
-            {
-                VerifyReader("SendVariantParam", dr, expectedTypeName, expectedBaseTypeName);
-            }
+            using SqlDataReader dr = GetReaderForVariant(paramValue, true);
+            VerifyReader("SendVariantParam", dr, expectedTypeName, expectedBaseTypeName);
         }
         /// <summary>
         /// Round trip sql_variant value using SqlBulkCopy.
@@ -113,93 +111,83 @@ private static void SendVariantBulkCopy(object paramValue, string expectedTypeNa
             string bulkCopyTableName = DataTestUtility.GetUniqueNameForSqlServer("bulkDest");
 
             // Fetch reader using type.
-            using (SqlDataReader dr = GetReaderForVariant(paramValue, false))
+            using SqlDataReader dr = GetReaderForVariant(paramValue, false);
+            using SqlConnection connBulk = new(s_connStr);
+            connBulk.Open();
+
+            ExecuteSQL(connBulk, "create table dbo.{0} (f1 sql_variant)", bulkCopyTableName);
+            try
             {
-                using (SqlConnection connBulk = new SqlConnection(s_connStr))
+                // Perform bulk copy to target.
+                using (SqlBulkCopy bulkCopy = new(connBulk))
                 {
-                    connBulk.Open();
-
-                    ExecuteSQL(connBulk, "create table dbo.{0} (f1 sql_variant)", bulkCopyTableName);
-                    try
-                    {
-                        // Perform bulk copy to target.
-                        using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connBulk))
-                        {
-                            bulkCopy.BulkCopyTimeout = 60;
-                            bulkCopy.BatchSize = 1;
-                            bulkCopy.DestinationTableName = bulkCopyTableName;
-                            bulkCopy.WriteToServer(dr);
-                        }
+                    bulkCopy.BulkCopyTimeout = 60;
+                    bulkCopy.BatchSize = 1;
+                    bulkCopy.DestinationTableName = bulkCopyTableName;
+                    bulkCopy.WriteToServer(dr);
+                }
 
-                        // Verify target.
-                        using (SqlCommand cmd = connBulk.CreateCommand())
-                        {
-                            cmd.CommandText = string.Format("select f1, sql_variant_property(f1,'BaseType') as BaseType from {0}", bulkCopyTableName);
-                            using (SqlDataReader drVerify = cmd.ExecuteReader())
-                            {
-                                VerifyReader("SendVariantBulkCopy[SqlDataReader]", drVerify, expectedTypeName, expectedBaseTypeName);
-                            }
-                        }
+                // Verify target.
+                using (SqlCommand cmd = connBulk.CreateCommand())
+                {
+                    cmd.CommandText = string.Format("select f1, sql_variant_property(f1,'BaseType') as BaseType from {0}", bulkCopyTableName);
+                    using SqlDataReader drVerify = cmd.ExecuteReader();
+                    VerifyReader("SendVariantBulkCopy[SqlDataReader]", drVerify, expectedTypeName, expectedBaseTypeName);
+                }
 
-                        // Truncate target table for next pass.
-                        ExecuteSQL(connBulk, "truncate table {0}", bulkCopyTableName);
+                // Truncate target table for next pass.
+                ExecuteSQL(connBulk, "truncate table {0}", bulkCopyTableName);
 
-                        // Send using DataTable as source.
-                        DataTable t = new DataTable();
-                        t.Columns.Add("f1", typeof(object));
-                        t.Rows.Add(new object[] { paramValue });
+                // Send using DataTable as source.
+                DataTable t = new();
+                t.Columns.Add("f1", typeof(object));
+                t.Rows.Add(new object[] { paramValue });
 
-                        // Perform bulk copy to target.
-                        using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connBulk))
-                        {
-                            bulkCopy.BulkCopyTimeout = 60;
-                            bulkCopy.BatchSize = 1;
-                            bulkCopy.DestinationTableName = bulkCopyTableName;
-                            bulkCopy.WriteToServer(t, DataRowState.Added);
-                        }
+                // Perform bulk copy to target.
+                using (SqlBulkCopy bulkCopy = new(connBulk))
+                {
+                    bulkCopy.BulkCopyTimeout = 60;
+                    bulkCopy.BatchSize = 1;
+                    bulkCopy.DestinationTableName = bulkCopyTableName;
+                    bulkCopy.WriteToServer(t, DataRowState.Added);
+                }
 
-                        // Verify target.
-                        using (SqlCommand cmd = connBulk.CreateCommand())
-                        {
-                            cmd.CommandText = string.Format("select f1, sql_variant_property(f1,'BaseType') as BaseType from {0}", bulkCopyTableName);
-                            using (SqlDataReader drVerify = cmd.ExecuteReader())
-                            {
-                                VerifyReader("SendVariantBulkCopy[DataTable]", drVerify, expectedTypeName, expectedBaseTypeName);
-                            }
-                        }
+                // Verify target.
+                using (SqlCommand cmd = connBulk.CreateCommand())
+                {
+                    cmd.CommandText = string.Format("select f1, sql_variant_property(f1,'BaseType') as BaseType from {0}", bulkCopyTableName);
+                    using SqlDataReader drVerify = cmd.ExecuteReader();
+                    VerifyReader("SendVariantBulkCopy[DataTable]", drVerify, expectedTypeName, expectedBaseTypeName);
+                }
 
-                        // Truncate target table for next pass.
-                        ExecuteSQL(connBulk, "truncate table {0}", bulkCopyTableName);
+                // Truncate target table for next pass.
+                ExecuteSQL(connBulk, "truncate table {0}", bulkCopyTableName);
 
-                        // Send using DataRow as source.
-                        DataRow[] rowToSend = t.Select();
+                // Send using DataRow as source.
+                DataRow[] rowToSend = t.Select();
 
-                        // Perform bulk copy to target.
-                        using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connBulk))
-                        {
-                            bulkCopy.BulkCopyTimeout = 60;
-                            bulkCopy.BatchSize = 1;
-                            bulkCopy.DestinationTableName = bulkCopyTableName;
-                            bulkCopy.WriteToServer(rowToSend);
-                        }
+                // Perform bulk copy to target.
+                using (SqlBulkCopy bulkCopy = new(connBulk))
+                {
+                    bulkCopy.BulkCopyTimeout = 60;
+                    bulkCopy.BatchSize = 1;
+                    bulkCopy.DestinationTableName = bulkCopyTableName;
+                    bulkCopy.WriteToServer(rowToSend);
+                }
 
-                        // Verify target.
-                        using (SqlCommand cmd = connBulk.CreateCommand())
-                        {
-                            cmd.CommandText = string.Format("select f1, sql_variant_property(f1,'BaseType') as BaseType from {0}", bulkCopyTableName);
-                            using (SqlDataReader drVerify = cmd.ExecuteReader())
-                            {
-                                VerifyReader("SendVariantBulkCopy[DataRow]", drVerify, expectedTypeName, expectedBaseTypeName);
-                            }
-                        }
-                    }
-                    finally
-                    {
-                        // Cleanup target table.
-                        ExecuteSQL(connBulk, "drop table {0}", bulkCopyTableName);
-                    }
+                // Verify target.
+                using (SqlCommand cmd = connBulk.CreateCommand())
+                {
+                    cmd.CommandText = string.Format("select f1, sql_variant_property(f1,'BaseType') as BaseType from {0}", bulkCopyTableName);
+                    using SqlDataReader drVerify = cmd.ExecuteReader();
+                    VerifyReader("SendVariantBulkCopy[DataRow]", drVerify, expectedTypeName, expectedBaseTypeName);
                 }
             }
+            finally
+            {
+                // Cleanup target table.
+                ExecuteSQL(connBulk, "drop table {0}", bulkCopyTableName);
+            }
         }
         /// <summary>
         /// Round trip sql_variant value using TVP.
@@ -208,54 +196,46 @@ private static void SendVariantTvp(object paramValue, string expectedTypeName, s
         {
             string tvpTypeName = DataTestUtility.GetUniqueNameForSqlServer("tvpVariant");
 
-            using (SqlConnection connTvp = new SqlConnection(s_connStr))
-            {
-                connTvp.Open();
+            using SqlConnection connTvp = new(s_connStr);
+            connTvp.Open();
 
-                ExecuteSQL(connTvp, "create type dbo.{0} as table (f1 sql_variant)", tvpTypeName);
-                try
+            ExecuteSQL(connTvp, "create type dbo.{0} as table (f1 sql_variant)", tvpTypeName);
+            try
+            {
+                // Send TVP using SqlMetaData.
+                SqlMetaData[] metadata = new SqlMetaData[1];
+                metadata[0] = new SqlMetaData("f1", SqlDbType.Variant);
+                SqlDataRecord[] record = new SqlDataRecord[1];
+                record[0] = new SqlDataRecord(metadata);
+                record[0].SetValue(0, paramValue);
+
+                using (SqlCommand cmd = connTvp.CreateCommand())
                 {
-                    // Send TVP using SqlMetaData.
-                    SqlMetaData[] metadata = new SqlMetaData[1];
-                    metadata[0] = new SqlMetaData("f1", SqlDbType.Variant);
-                    SqlDataRecord[] record = new SqlDataRecord[1];
-                    record[0] = new SqlDataRecord(metadata);
-                    record[0].SetValue(0, paramValue);
-
-                    using (SqlCommand cmd = connTvp.CreateCommand())
-                    {
-                        cmd.CommandText = "select f1, sql_variant_property(f1,'BaseType') as BaseType from @tvpParam";
-                        SqlParameter p = cmd.Parameters.AddWithValue("@tvpParam", record);
-                        p.SqlDbType = SqlDbType.Structured;
-                        p.TypeName = string.Format("dbo.{0}", tvpTypeName);
-                        using (SqlDataReader dr = cmd.ExecuteReader())
-                        {
-                            VerifyReader("SendVariantTvp[SqlMetaData]", dr, expectedTypeName, expectedBaseTypeName);
-                        }
-                    }
-
-                    // Send TVP using SqlDataReader.
-                    using (SqlDataReader dr = GetReaderForVariant(paramValue, false))
-                    {
-                        using (SqlCommand cmd = connTvp.CreateCommand())
-                        {
-                            cmd.CommandText = "select f1, sql_variant_property(f1,'BaseType') as BaseType from @tvpParam";
-                            SqlParameter p = cmd.Parameters.AddWithValue("@tvpParam", dr);
-                            p.SqlDbType = SqlDbType.Structured;
-                            p.TypeName = string.Format("dbo.{0}", tvpTypeName);
-                            using (SqlDataReader dr2 = cmd.ExecuteReader())
-                            {
-                                VerifyReader("SendVariantTvp[SqlDataReader]", dr2, expectedTypeName, expectedBaseTypeName);
-                            }
-                        }
-                    }
+                    cmd.CommandText = "select f1, sql_variant_property(f1,'BaseType') as BaseType from @tvpParam";
+                    SqlParameter p = cmd.Parameters.AddWithValue("@tvpParam", record);
+                    p.SqlDbType = SqlDbType.Structured;
+                    p.TypeName = string.Format("dbo.{0}", tvpTypeName);
+                    using SqlDataReader dr = cmd.ExecuteReader();
+                    VerifyReader("SendVariantTvp[SqlMetaData]", dr, expectedTypeName, expectedBaseTypeName);
                 }
-                finally
+
+                // Send TVP using SqlDataReader.
+                using (SqlDataReader dr = GetReaderForVariant(paramValue, false))
                 {
-                    // Cleanup tvp type.
-                    ExecuteSQL(connTvp, "drop type {0}", tvpTypeName);
+                    using SqlCommand cmd = connTvp.CreateCommand();
+                    cmd.CommandText = "select f1, sql_variant_property(f1,'BaseType') as BaseType from @tvpParam";
+                    SqlParameter p = cmd.Parameters.AddWithValue("@tvpParam", dr);
+                    p.SqlDbType = SqlDbType.Structured;
+                    p.TypeName = string.Format("dbo.{0}", tvpTypeName);
+                    using SqlDataReader dr2 = cmd.ExecuteReader();
+                    VerifyReader("SendVariantTvp[SqlDataReader]", dr2, expectedTypeName, expectedBaseTypeName);
                 }
             }
+            finally
+            {
+                // Cleanup tvp type.
+                ExecuteSQL(connTvp, "drop type {0}", tvpTypeName);
+            }
         }
         /// <summary>
         /// Helper to execute t-sql with variable object name.
@@ -265,22 +245,9 @@ private static void SendVariantTvp(object paramValue, string expectedTypeName, s
         /// <param name="objectName">Variable object name for t-sql</param>
         private static void ExecuteSQL(SqlConnection conn, string formatSql, string objectName)
         {
-            using (SqlCommand cmd = conn.CreateCommand())
-            {
-                cmd.CommandText = string.Format(formatSql, objectName);
-                cmd.ExecuteNonQuery();
-            }
-        }
-        /// <summary>
-        /// Simple helper to execute t-sql.
-        /// </summary>
-        private static void ExecuteSQL(SqlConnection conn, string sql)
-        {
-            using (SqlCommand cmd = conn.CreateCommand())
-            {
-                cmd.CommandText = sql;
-                cmd.ExecuteNonQuery();
-            }
+            using SqlCommand cmd = conn.CreateCommand();
+            cmd.CommandText = string.Format(formatSql, objectName);
+            cmd.ExecuteNonQuery();
         }
     }
 }
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/SteAttribute.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/SteAttribute.cs
index 2dcafd004b..be82171115 100644
--- a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/SteAttribute.cs
+++ b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/SteAttribute.cs
@@ -8,19 +8,19 @@ namespace Microsoft.Data.SqlClient.ManualTesting.Tests
 {
     public class SteAttributeKey
     {
-        public static readonly SteAttributeKey SqlDbType = new SteAttributeKey();
-        public static readonly SteAttributeKey MultiValued = new SteAttributeKey();
-        public static readonly SteAttributeKey Value = new SteAttributeKey();
-        public static readonly SteAttributeKey MaxLength = new SteAttributeKey();
-        public static readonly SteAttributeKey Precision = new SteAttributeKey();
-        public static readonly SteAttributeKey Scale = new SteAttributeKey();
-        public static readonly SteAttributeKey LocaleId = new SteAttributeKey();
-        public static readonly SteAttributeKey CompareOptions = new SteAttributeKey();
-        public static readonly SteAttributeKey TypeName = new SteAttributeKey();
-        public static readonly SteAttributeKey Type = new SteAttributeKey();
-        public static readonly SteAttributeKey Fields = new SteAttributeKey();
-        public static readonly SteAttributeKey Offset = new SteAttributeKey();
-        public static readonly SteAttributeKey Length = new SteAttributeKey();
+        public static readonly SteAttributeKey SqlDbType = new();
+        public static readonly SteAttributeKey MultiValued = new();
+        public static readonly SteAttributeKey Value = new();
+        public static readonly SteAttributeKey MaxLength = new();
+        public static readonly SteAttributeKey Precision = new();
+        public static readonly SteAttributeKey Scale = new();
+        public static readonly SteAttributeKey LocaleId = new();
+        public static readonly SteAttributeKey CompareOptions = new();
+        public static readonly SteAttributeKey TypeName = new();
+        public static readonly SteAttributeKey Type = new();
+        public static readonly SteAttributeKey Fields = new();
+        public static readonly SteAttributeKey Offset = new();
+        public static readonly SteAttributeKey Length = new();
 
         public static readonly IList<SteAttributeKey> MetaDataKeys = new List<SteAttributeKey>(
                 new SteAttributeKey[] {
@@ -44,8 +44,8 @@ public class SteAttributeKey
 
     public class SteAttribute
     {
-        private SteAttributeKey _key;
-        private object _value;
+        private readonly SteAttributeKey _key;
+        private readonly object _value;
 
         public SteAttribute(SteAttributeKey key, object value)
         {
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/SteParam.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/SteParam.cs
index 153d1fe324..cb6d2de7d5 100644
--- a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/SteParam.cs
+++ b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/SteParam.cs
@@ -13,9 +13,8 @@ public class SteParam
         // Map values from a permutation into a parameter (doesn't currently map values)
         public static void Map(StePermutation perm, SqlParameter param)
         {
-            object attr;
             bool didSetSqlDbType = false;
-            if (perm.TryGetValue(SteAttributeKey.SqlDbType, out attr) && (attr != SteTypeBoundaries.s_doNotUseMarker))
+            if (perm.TryGetValue(SteAttributeKey.SqlDbType, out object attr) && (attr != SteTypeBoundaries.s_doNotUseMarker))
             {
                 param.SqlDbType = (SqlDbType)attr;
                 didSetSqlDbType = true;
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/StePermutationSet.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/StePermutationSet.cs
index 79b3364fd4..82754022a9 100644
--- a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/StePermutationSet.cs
+++ b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/StePermutationSet.cs
@@ -5,6 +5,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Text;
 
 namespace Microsoft.Data.SqlClient.ManualTesting.Tests
 {
@@ -12,7 +13,7 @@ public class StePermutation : Dictionary<SteAttributeKey, object>
     {
         public override string ToString()
         {
-            System.Text.StringBuilder b = new System.Text.StringBuilder();
+            StringBuilder b = new();
             bool needSeparator = false;
             foreach (KeyValuePair<SteAttributeKey, object> pair in this)
             {
@@ -36,15 +37,9 @@ public override string ToString()
     public abstract class StePermutationGenerator : IEnumerable<StePermutation>
     {
         // standard GetEnumerator, implemented in terms of specialized enumerator
-        public IEnumerator<StePermutation> GetEnumerator()
-        {
-            return this.GetEnumerator(this.DefaultKeys);
-        }
+        public IEnumerator<StePermutation> GetEnumerator() => GetEnumerator(DefaultKeys);
 
-        IEnumerator IEnumerable.GetEnumerator()
-        {
-            return this.GetEnumerator(this.DefaultKeys);
-        }
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(DefaultKeys);
 
         public abstract IEnumerable<SteAttributeKey> DefaultKeys
         {
@@ -70,8 +65,8 @@ private enum LogicalPosition
                 AfterElements             // Position is after final element
             }
 
-            private SteSimplePermutationGenerator _parent;            // Source of enumeration elements
-            private List<SteAttributeKey> _keysOfInterest;    // attribute keys to use to generate permutations
+            private readonly SteSimplePermutationGenerator _parent;            // Source of enumeration elements
+            private readonly List<SteAttributeKey> _keysOfInterest;    // attribute keys to use to generate permutations
             private IEnumerator[] _position;          // One enumerator for each non-empty attribute list in parent
             private LogicalPosition _logicalPosition;   // Logical positioning of self
 
@@ -87,8 +82,7 @@ public SteSimplePermEnumerator(SteSimplePermutationGenerator parent, IEnumerable
                 _keysOfInterest = new List<SteAttributeKey>();
                 foreach (SteAttributeKey key in keysOfInterest)
                 {
-                    ArrayList list;
-                    if (_parent.AttributeLists.TryGetValue(key, out list) && list.Count > 0)
+                    if (_parent.AttributeLists.TryGetValue(key, out ArrayList list) && list.Count > 0)
                     {
                         _keysOfInterest.Add(key);
                     }
@@ -157,13 +151,7 @@ public StePermutation Current
                 }
             }
 
-            object IEnumerator.Current
-            {
-                get
-                {
-                    return this.Current;
-                }
-            }
+            object IEnumerator.Current => Current;
 
             // Standard enumerator restart method
             public void Reset()
@@ -196,7 +184,7 @@ public void Dispose()
         }
 
         // permutationGenerator private fields
-        private Dictionary<SteAttributeKey, ArrayList> _permutationBase;
+        private readonly Dictionary<SteAttributeKey, ArrayList> _permutationBase;
 
         // generator's ctor
         public SteSimplePermutationGenerator()
@@ -216,8 +204,7 @@ public override IEnumerable<SteAttributeKey> DefaultKeys
         // Add a new attribute to the set
         public void Add(SteAttributeKey key, object attribute)
         {
-            ArrayList targetList;
-            if (!_permutationBase.TryGetValue(key, out targetList))
+            if (!_permutationBase.TryGetValue(key, out ArrayList targetList))
             {
                 targetList = new ArrayList();
                 _permutationBase.Add(key, targetList);
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/SteTypeBoundaries.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/SteTypeBoundaries.cs
index aa11d34b94..b469c0795b 100644
--- a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/SteTypeBoundaries.cs
+++ b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/SteTypeBoundaries.cs
@@ -7,6 +7,7 @@
 using System.Collections.Generic;
 using System.Data;
 using System.Data.SqlTypes;
+using System.Text;
 
 namespace Microsoft.Data.SqlClient.ManualTesting.Tests
 {
@@ -14,7 +15,7 @@ public abstract class SteTypeBoundaries : StePermutationGenerator
     {
         // Use this marker for attribute value to indicate the attribute is not used 
         // (ex. option where Decimal parameter's Scale property should not be set at all)
-        public static object s_doNotUseMarker = new object();
+        public static object s_doNotUseMarker = new();
     }
 
     // simple types can just wrap a simple permutation generator
@@ -31,199 +32,225 @@ public class SteSimpleTypeBoundaries : SteTypeBoundaries
         public static readonly IList<SteSimpleTypeBoundaries> s_udtsOnly;
         static SteSimpleTypeBoundaries()
         {
-            List<SteSimpleTypeBoundaries> list = new List<SteSimpleTypeBoundaries>();
+            List<SteSimpleTypeBoundaries> list = new();
 
             // DevNote: Don't put null value attributes first -- it confuses DataTable generation for SteStructuredTypeBoundaries
 
             // BigInt
-            SteSimplePermutationGenerator type = new SteSimplePermutationGenerator();
-            type.Add(SteAttributeKey.SqlDbType, SqlDbType.BigInt);
-            type.Add(SteAttributeKey.Value, (long)0);
-            type.Add(SteAttributeKey.Value, long.MaxValue);
-            type.Add(SteAttributeKey.Value, long.MinValue);
-            type.Add(SteAttributeKey.Value, new SqlInt64(long.MaxValue));
-            type.Add(SteAttributeKey.Value, new SqlInt64(long.MinValue));
-            type.Add(SteAttributeKey.Value, null);
-            type.Add(SteAttributeKey.Value, DBNull.Value);
+            SteSimplePermutationGenerator type = new()
+            {
+                { SteAttributeKey.SqlDbType, SqlDbType.BigInt },
+                { SteAttributeKey.Value, (long)0 },
+                { SteAttributeKey.Value, long.MaxValue },
+                { SteAttributeKey.Value, long.MinValue },
+                { SteAttributeKey.Value, new SqlInt64(long.MaxValue) },
+                { SteAttributeKey.Value, new SqlInt64(long.MinValue) },
+                { SteAttributeKey.Value, null },
+                { SteAttributeKey.Value, DBNull.Value }
+            };
             list.Add(new SteSimpleTypeBoundaries(type));
 
             // Binary types
-            type = new SteSimplePermutationGenerator();
-            type.Add(SteAttributeKey.SqlDbType, SqlDbType.Binary);
-            type.Add(SteAttributeKey.SqlDbType, SqlDbType.VarBinary);
-            type.Add(SteAttributeKey.SqlDbType, SqlDbType.Image);
-            type.Add(SteAttributeKey.MaxLength, 1);    // a small value
-            type.Add(SteAttributeKey.MaxLength, 40);   // Somewhere in the middle
-            type.Add(SteAttributeKey.MaxLength, 8000); // Couple values around maximum tds length
-            type.Add(SteAttributeKey.Value, CreateByteArray(0));
-            type.Add(SteAttributeKey.Value, CreateByteArray(1));
-            type.Add(SteAttributeKey.Value, CreateByteArray(50));
-            type.Add(SteAttributeKey.Value, s_moderateSizeByteArray);
-            type.Add(SteAttributeKey.Value, new SqlBytes(CreateByteArray(0)));
-            type.Add(SteAttributeKey.Value, new SqlBytes(CreateByteArray(1)));
-            type.Add(SteAttributeKey.Value, new SqlBytes(CreateByteArray(40)));
-            type.Add(SteAttributeKey.Value, new SqlBytes(s_moderateSizeByteArray));
-            type.Add(SteAttributeKey.Value, null);
-            type.Add(SteAttributeKey.Value, DBNull.Value);
-            type.Add(SteAttributeKey.Offset, s_doNotUseMarker);
-            type.Add(SteAttributeKey.Offset, -1);
-            type.Add(SteAttributeKey.Offset, 0);
-            type.Add(SteAttributeKey.Offset, 10);
-            type.Add(SteAttributeKey.Offset, 8000);
-            type.Add(SteAttributeKey.Offset, int.MaxValue);
-            type.Add(SteAttributeKey.Length, 0);
-            type.Add(SteAttributeKey.Length, 40);
-            type.Add(SteAttributeKey.Length, 8000);
-            type.Add(SteAttributeKey.Length, 1000000);
-            type.Add(SteAttributeKey.Length, -1);
+            type = new SteSimplePermutationGenerator
+            {
+                { SteAttributeKey.SqlDbType, SqlDbType.Binary },
+                { SteAttributeKey.SqlDbType, SqlDbType.VarBinary },
+                { SteAttributeKey.SqlDbType, SqlDbType.Image },
+                { SteAttributeKey.MaxLength, 1 },    // a small value
+                { SteAttributeKey.MaxLength, 40 },   // Somewhere in the middle
+                { SteAttributeKey.MaxLength, 8000 }, // Couple values around maximum tds length
+                { SteAttributeKey.Value, CreateByteArray(0) },
+                { SteAttributeKey.Value, CreateByteArray(1) },
+                { SteAttributeKey.Value, CreateByteArray(50) },
+                { SteAttributeKey.Value, s_moderateSizeByteArray },
+                { SteAttributeKey.Value, new SqlBytes(CreateByteArray(0)) },
+                { SteAttributeKey.Value, new SqlBytes(CreateByteArray(1)) },
+                { SteAttributeKey.Value, new SqlBytes(CreateByteArray(40)) },
+                { SteAttributeKey.Value, new SqlBytes(s_moderateSizeByteArray) },
+                { SteAttributeKey.Value, null },
+                { SteAttributeKey.Value, DBNull.Value },
+                { SteAttributeKey.Offset, s_doNotUseMarker },
+                { SteAttributeKey.Offset, -1 },
+                { SteAttributeKey.Offset, 0 },
+                { SteAttributeKey.Offset, 10 },
+                { SteAttributeKey.Offset, 8000 },
+                { SteAttributeKey.Offset, int.MaxValue },
+                { SteAttributeKey.Length, 0 },
+                { SteAttributeKey.Length, 40 },
+                { SteAttributeKey.Length, 8000 },
+                { SteAttributeKey.Length, 1000000 },
+                { SteAttributeKey.Length, -1 }
+            };
             list.Add(new SteSimpleTypeBoundaries(type));
 
             // Byte
-            type = new SteSimplePermutationGenerator();
-            type.Add(SteAttributeKey.SqlDbType, SqlDbType.TinyInt);
-            type.Add(SteAttributeKey.Value, byte.MaxValue);
-            type.Add(SteAttributeKey.Value, byte.MinValue);
-            type.Add(SteAttributeKey.Value, null);
-            type.Add(SteAttributeKey.Value, DBNull.Value);
+            type = new SteSimplePermutationGenerator
+            {
+                { SteAttributeKey.SqlDbType, SqlDbType.TinyInt },
+                { SteAttributeKey.Value, byte.MaxValue },
+                { SteAttributeKey.Value, byte.MinValue },
+                { SteAttributeKey.Value, null },
+                { SteAttributeKey.Value, DBNull.Value }
+            };
             list.Add(new SteSimpleTypeBoundaries(type));
 
             // Character (ANSI)
-            type = new SteSimplePermutationGenerator();
-            type.Add(SteAttributeKey.SqlDbType, SqlDbType.Char);
-            type.Add(SteAttributeKey.SqlDbType, SqlDbType.Text);
-            type.Add(SteAttributeKey.SqlDbType, SqlDbType.VarChar);
-            type.Add(SteAttributeKey.MaxLength, 1);
-            type.Add(SteAttributeKey.MaxLength, 30);
-            type.Add(SteAttributeKey.MaxLength, 8000);
-            type.Add(SteAttributeKey.Value, CreateString(1));
-            type.Add(SteAttributeKey.Value, CreateString(20));
-            type.Add(SteAttributeKey.Value, s_moderateSizeString);
-            type.Add(SteAttributeKey.Value, CreateString(1).ToCharArray());
-            type.Add(SteAttributeKey.Value, CreateString(25).ToCharArray());
-            type.Add(SteAttributeKey.Value, s_moderateSizeCharArray);
-            type.Add(SteAttributeKey.Value, new SqlChars(CreateString(1).ToCharArray()));
-            type.Add(SteAttributeKey.Value, new SqlChars(CreateString(30).ToCharArray()));
-            type.Add(SteAttributeKey.Value, new SqlChars(s_moderateSizeCharArray));
-            type.Add(SteAttributeKey.Value, null);
-            type.Add(SteAttributeKey.Value, DBNull.Value);
+            type = new SteSimplePermutationGenerator
+            {
+                { SteAttributeKey.SqlDbType, SqlDbType.Char },
+                { SteAttributeKey.SqlDbType, SqlDbType.Text },
+                { SteAttributeKey.SqlDbType, SqlDbType.VarChar },
+                { SteAttributeKey.MaxLength, 1 },
+                { SteAttributeKey.MaxLength, 30 },
+                { SteAttributeKey.MaxLength, 8000 },
+                { SteAttributeKey.Value, CreateString(1) },
+                { SteAttributeKey.Value, CreateString(20) },
+                { SteAttributeKey.Value, s_moderateSizeString },
+                { SteAttributeKey.Value, CreateString(1).ToCharArray() },
+                { SteAttributeKey.Value, CreateString(25).ToCharArray() },
+                { SteAttributeKey.Value, s_moderateSizeCharArray },
+                { SteAttributeKey.Value, new SqlChars(CreateString(1).ToCharArray()) },
+                { SteAttributeKey.Value, new SqlChars(CreateString(30).ToCharArray()) },
+                { SteAttributeKey.Value, new SqlChars(s_moderateSizeCharArray) },
+                { SteAttributeKey.Value, null },
+                { SteAttributeKey.Value, DBNull.Value }
+            };
             list.Add(new SteSimpleTypeBoundaries(type));
 
             // Character (UNICODE)
-            type = new SteSimplePermutationGenerator();
-            type.Add(SteAttributeKey.SqlDbType, SqlDbType.NChar);
-            type.Add(SteAttributeKey.SqlDbType, SqlDbType.NText);
-            type.Add(SteAttributeKey.SqlDbType, SqlDbType.NVarChar);
-            type.Add(SteAttributeKey.MaxLength, 1);
-            type.Add(SteAttributeKey.MaxLength, 35);
-            type.Add(SteAttributeKey.MaxLength, 4000);
-            type.Add(SteAttributeKey.Value, CreateString(1));
-            type.Add(SteAttributeKey.Value, CreateString(15));
-            type.Add(SteAttributeKey.Value, s_moderateSizeString);
-            type.Add(SteAttributeKey.Value, CreateString(1).ToCharArray());
-            type.Add(SteAttributeKey.Value, CreateString(20).ToCharArray());
-            type.Add(SteAttributeKey.Value, s_moderateSizeCharArray);
-            type.Add(SteAttributeKey.Value, new SqlChars(CreateString(1).ToCharArray()));
-            type.Add(SteAttributeKey.Value, new SqlChars(CreateString(25).ToCharArray()));
-            type.Add(SteAttributeKey.Value, new SqlChars(s_moderateSizeCharArray));
-            type.Add(SteAttributeKey.Value, null);
-            type.Add(SteAttributeKey.Value, DBNull.Value);
+            type = new SteSimplePermutationGenerator
+            {
+                { SteAttributeKey.SqlDbType, SqlDbType.NChar },
+                { SteAttributeKey.SqlDbType, SqlDbType.NText },
+                { SteAttributeKey.SqlDbType, SqlDbType.NVarChar },
+                { SteAttributeKey.MaxLength, 1 },
+                { SteAttributeKey.MaxLength, 35 },
+                { SteAttributeKey.MaxLength, 4000 },
+                { SteAttributeKey.Value, CreateString(1) },
+                { SteAttributeKey.Value, CreateString(15) },
+                { SteAttributeKey.Value, s_moderateSizeString },
+                { SteAttributeKey.Value, CreateString(1).ToCharArray() },
+                { SteAttributeKey.Value, CreateString(20).ToCharArray() },
+                { SteAttributeKey.Value, s_moderateSizeCharArray },
+                { SteAttributeKey.Value, new SqlChars(CreateString(1).ToCharArray()) },
+                { SteAttributeKey.Value, new SqlChars(CreateString(25).ToCharArray()) },
+                { SteAttributeKey.Value, new SqlChars(s_moderateSizeCharArray) },
+                { SteAttributeKey.Value, null },
+                { SteAttributeKey.Value, DBNull.Value }
+            };
             list.Add(new SteSimpleTypeBoundaries(type));
 
             // DateTime
-            type = new SteSimplePermutationGenerator();
-            type.Add(SteAttributeKey.SqlDbType, SqlDbType.DateTime);
-            type.Add(SteAttributeKey.SqlDbType, SqlDbType.SmallDateTime);
-            type.Add(SteAttributeKey.Value, new DateTime(1753, 1, 1));
-            type.Add(SteAttributeKey.Value, new SqlDateTime(new DateTime(1753, 1, 1)));  // min SqlDateTime
-            type.Add(SteAttributeKey.Value, null);
-            type.Add(SteAttributeKey.Value, DBNull.Value);
+            type = new SteSimplePermutationGenerator
+            {
+                { SteAttributeKey.SqlDbType, SqlDbType.DateTime },
+                { SteAttributeKey.SqlDbType, SqlDbType.SmallDateTime },
+                { SteAttributeKey.Value, new DateTime(1753, 1, 1) },
+                { SteAttributeKey.Value, new SqlDateTime(new DateTime(1753, 1, 1)) },  // min SqlDateTime
+                { SteAttributeKey.Value, null },
+                { SteAttributeKey.Value, DBNull.Value }
+            };
             list.Add(new SteSimpleTypeBoundaries(type));
 
             // Decimal
             //  the TVP test isn't robust in the face of OverflowExceptions on input, so a number of these
             //  values are commented out and other numbers substituted.
-            type = new SteSimplePermutationGenerator();
-            type.Add(SteAttributeKey.SqlDbType, SqlDbType.Decimal);
-            type.Add(SteAttributeKey.Precision, (byte)38);
-            type.Add(SteAttributeKey.Scale, (byte)0);
-            type.Add(SteAttributeKey.Scale, (byte)10);
-            type.Add(SteAttributeKey.Value, (decimal)0);
-            type.Add(SteAttributeKey.Value, decimal.MaxValue / 10000000000);
-            type.Add(SteAttributeKey.Value, new SqlDecimal(0));
-            type.Add(SteAttributeKey.Value, ((SqlDecimal)1234567890123456.789012345678M) * 100); // Bigger than a Decimal
-            type.Add(SteAttributeKey.Value, null);
-            type.Add(SteAttributeKey.Value, DBNull.Value);
+            type = new SteSimplePermutationGenerator
+            {
+                { SteAttributeKey.SqlDbType, SqlDbType.Decimal },
+                { SteAttributeKey.Precision, (byte)38 },
+                { SteAttributeKey.Scale, (byte)0 },
+                { SteAttributeKey.Scale, (byte)10 },
+                { SteAttributeKey.Value, (decimal)0 },
+                { SteAttributeKey.Value, decimal.MaxValue / 10000000000 },
+                { SteAttributeKey.Value, new SqlDecimal(0) },
+                { SteAttributeKey.Value, ((SqlDecimal)1234567890123456.789012345678M) * 100 }, // Bigger than a Decimal
+                { SteAttributeKey.Value, null },
+                { SteAttributeKey.Value, DBNull.Value }
+            };
             list.Add(new SteSimpleTypeBoundaries(type));
 
             // Float
-            type = new SteSimplePermutationGenerator();
-            type.Add(SteAttributeKey.SqlDbType, SqlDbType.Float);
-            type.Add(SteAttributeKey.Value, (double)0);
-            type.Add(SteAttributeKey.Value, double.MaxValue);
-            type.Add(SteAttributeKey.Value, double.MinValue);
-            type.Add(SteAttributeKey.Value, new SqlDouble(double.MaxValue));
-            type.Add(SteAttributeKey.Value, new SqlDouble(double.MinValue));
-            type.Add(SteAttributeKey.Value, null);
-            type.Add(SteAttributeKey.Value, DBNull.Value);
+            type = new SteSimplePermutationGenerator
+            {
+                { SteAttributeKey.SqlDbType, SqlDbType.Float },
+                { SteAttributeKey.Value, (double)0 },
+                { SteAttributeKey.Value, double.MaxValue },
+                { SteAttributeKey.Value, double.MinValue },
+                { SteAttributeKey.Value, new SqlDouble(double.MaxValue) },
+                { SteAttributeKey.Value, new SqlDouble(double.MinValue) },
+                { SteAttributeKey.Value, null },
+                { SteAttributeKey.Value, DBNull.Value }
+            };
             list.Add(new SteSimpleTypeBoundaries(type));
 
             // Int
-            type = new SteSimplePermutationGenerator();
-            type.Add(SteAttributeKey.SqlDbType, SqlDbType.Int);
-            type.Add(SteAttributeKey.Value, (int)0);
-            type.Add(SteAttributeKey.Value, int.MaxValue);
-            type.Add(SteAttributeKey.Value, int.MinValue);
-            type.Add(SteAttributeKey.Value, new SqlInt32(int.MaxValue));
-            type.Add(SteAttributeKey.Value, new SqlInt32(int.MinValue));
-            type.Add(SteAttributeKey.Value, null);
-            type.Add(SteAttributeKey.Value, DBNull.Value);
+            type = new SteSimplePermutationGenerator
+            {
+                { SteAttributeKey.SqlDbType, SqlDbType.Int },
+                { SteAttributeKey.Value, (int)0 },
+                { SteAttributeKey.Value, int.MaxValue },
+                { SteAttributeKey.Value, int.MinValue },
+                { SteAttributeKey.Value, new SqlInt32(int.MaxValue) },
+                { SteAttributeKey.Value, new SqlInt32(int.MinValue) },
+                { SteAttributeKey.Value, null },
+                { SteAttributeKey.Value, DBNull.Value }
+            };
             list.Add(new SteSimpleTypeBoundaries(type));
 
             // Money types
-            type = new SteSimplePermutationGenerator();
-            type.Add(SteAttributeKey.SqlDbType, SqlDbType.Money);
-            type.Add(SteAttributeKey.SqlDbType, SqlDbType.SmallMoney);
-            type.Add(SteAttributeKey.Value, (decimal)0);
-            type.Add(SteAttributeKey.Value, (decimal)unchecked(((long)0x8000000000000000L) / 10000));
-            type.Add(SteAttributeKey.Value, (decimal)0x7FFFFFFFFFFFFFFFL / 10000);
-            type.Add(SteAttributeKey.Value, new decimal(-214748.3648)); // smallmoney min
-            type.Add(SteAttributeKey.Value, new decimal(214748.3647)); // smallmoney max
-            type.Add(SteAttributeKey.Value, new SqlMoney(((decimal)int.MaxValue) / 10000));
-            type.Add(SteAttributeKey.Value, new SqlMoney(((decimal)int.MinValue) / 10000));
-            type.Add(SteAttributeKey.Value, null);
-            type.Add(SteAttributeKey.Value, DBNull.Value);
+            type = new SteSimplePermutationGenerator
+            {
+                { SteAttributeKey.SqlDbType, SqlDbType.Money },
+                { SteAttributeKey.SqlDbType, SqlDbType.SmallMoney },
+                { SteAttributeKey.Value, (decimal)0 },
+                { SteAttributeKey.Value, (decimal)unchecked(((long)0x8000000000000000L) / 10000) },
+                { SteAttributeKey.Value, (decimal)0x7FFFFFFFFFFFFFFFL / 10000 },
+                { SteAttributeKey.Value, new decimal(-214748.3648) }, // smallmoney min
+                { SteAttributeKey.Value, new decimal(214748.3647) }, // smallmoney max
+                { SteAttributeKey.Value, new SqlMoney(((decimal)int.MaxValue) / 10000) },
+                { SteAttributeKey.Value, new SqlMoney(((decimal)int.MinValue) / 10000) },
+                { SteAttributeKey.Value, null },
+                { SteAttributeKey.Value, DBNull.Value }
+            };
             list.Add(new SteSimpleTypeBoundaries(type));
 
             // Real
-            type = new SteSimplePermutationGenerator();
-            type.Add(SteAttributeKey.SqlDbType, SqlDbType.Real);
-            type.Add(SteAttributeKey.Value, (float)0);
-            type.Add(SteAttributeKey.Value, float.MaxValue);
-            type.Add(SteAttributeKey.Value, float.MinValue);
-            type.Add(SteAttributeKey.Value, new SqlSingle(float.MaxValue));
-            type.Add(SteAttributeKey.Value, new SqlSingle(float.MinValue));
-            type.Add(SteAttributeKey.Value, null);
-            type.Add(SteAttributeKey.Value, DBNull.Value);
+            type = new SteSimplePermutationGenerator
+            {
+                { SteAttributeKey.SqlDbType, SqlDbType.Real },
+                { SteAttributeKey.Value, (float)0 },
+                { SteAttributeKey.Value, float.MaxValue },
+                { SteAttributeKey.Value, float.MinValue },
+                { SteAttributeKey.Value, new SqlSingle(float.MaxValue) },
+                { SteAttributeKey.Value, new SqlSingle(float.MinValue) },
+                { SteAttributeKey.Value, null },
+                { SteAttributeKey.Value, DBNull.Value }
+            };
             list.Add(new SteSimpleTypeBoundaries(type));
 
             // SmallInt
-            type = new SteSimplePermutationGenerator();
-            type.Add(SteAttributeKey.SqlDbType, SqlDbType.SmallInt);
-            type.Add(SteAttributeKey.Value, (short)0);
-            type.Add(SteAttributeKey.Value, short.MaxValue);
-            type.Add(SteAttributeKey.Value, short.MinValue);
-            type.Add(SteAttributeKey.Value, new SqlInt16(short.MaxValue));
-            type.Add(SteAttributeKey.Value, new SqlInt16(short.MinValue));
-            type.Add(SteAttributeKey.Value, null);
-            type.Add(SteAttributeKey.Value, DBNull.Value);
+            type = new SteSimplePermutationGenerator
+            {
+                { SteAttributeKey.SqlDbType, SqlDbType.SmallInt },
+                { SteAttributeKey.Value, (short)0 },
+                { SteAttributeKey.Value, short.MaxValue },
+                { SteAttributeKey.Value, short.MinValue },
+                { SteAttributeKey.Value, new SqlInt16(short.MaxValue) },
+                { SteAttributeKey.Value, new SqlInt16(short.MinValue) },
+                { SteAttributeKey.Value, null },
+                { SteAttributeKey.Value, DBNull.Value }
+            };
             list.Add(new SteSimpleTypeBoundaries(type));
 
             // UniqueIdentifier
-            type = new SteSimplePermutationGenerator();
-            type.Add(SteAttributeKey.SqlDbType, SqlDbType.UniqueIdentifier);
-            type.Add(SteAttributeKey.Value, new Guid());
-            type.Add(SteAttributeKey.Value, null);
-            type.Add(SteAttributeKey.Value, DBNull.Value);
+            type = new SteSimplePermutationGenerator
+            {
+                { SteAttributeKey.SqlDbType, SqlDbType.UniqueIdentifier },
+                { SteAttributeKey.Value, new Guid() },
+                { SteAttributeKey.Value, null },
+                { SteAttributeKey.Value, DBNull.Value }
+            };
             list.Add(new SteSimpleTypeBoundaries(type));
 
             // UDT
@@ -251,7 +278,7 @@ static SteSimpleTypeBoundaries()
             //UdtsOnly = list.AsReadOnly();
         }
 
-        private SteSimplePermutationGenerator _generator;
+        private readonly SteSimplePermutationGenerator _generator;
 
         public SteSimpleTypeBoundaries(SteSimplePermutationGenerator generator)
         {
@@ -271,11 +298,11 @@ public override IEnumerator<StePermutation> GetEnumerator(IEnumerable<SteAttribu
             return _generator.GetEnumerator(keysOfInterest);
         }
 
-        private const string __prefix = "Char: ";
+        private const string Prefix = "Char: ";
         public static string CreateString(int size)
         {
-            System.Text.StringBuilder b = new System.Text.StringBuilder();
-            b.Append(__prefix);
+            StringBuilder b = new();
+            b.Append(Prefix);
             for (int i = 0; i < s_theBigByteArray.Length && b.Length < size; i++)
             {
                 b.Append(s_theBigByteArray[i]);
@@ -341,19 +368,19 @@ private enum LogicalPosition
 
 
             // Value list can be static, since it'll only ever be used in one way.
-            private static IList<SteAttributeKey> __valueKey = new List<SteAttributeKey>(new SteAttributeKey[] { SteAttributeKey.Value });
+            private static readonly IList<SteAttributeKey> s_valueKey = new List<SteAttributeKey>(new SteAttributeKey[] { SteAttributeKey.Value });
 
-            private SteStructuredTypeBoundaries _parent;
-            private bool _isMultiValued;
-            private IList<SteAttributeKey> _metaDataKeysOfInterest; // metadata keys that should be used
+            private readonly SteStructuredTypeBoundaries _parent;
+            private readonly bool _isMultiValued;
+            private readonly IList<SteAttributeKey> _metaDataKeysOfInterest; // metadata keys that should be used
             private object[][] _separateValueList;  // use the value list separately?
             private IList<IEnumerator<StePermutation>> _fieldEnumerators; // List of enumerators over subordinate types
             private bool[] _completed;         // Which enumerators have already completed?
             private LogicalPosition _logicalPosition;   // Logical positioning of self
             private int _typeNumber;        // used to uniquely separate each type for this session
-            private string _typeNameBase;
+            private readonly string _typeNameBase;
             private StePermutation _current;
-            private StePermutation _rowCountColumn;
+            private readonly StePermutation _rowCountColumn;
 
             public SteStructuredTypeBoundariesEnumerator(
                             SteStructuredTypeBoundaries parent, IEnumerable<SteAttributeKey> keysOfInterest, bool isMultiValued)
@@ -408,13 +435,7 @@ public StePermutation Current
                 }
             }
 
-            object IEnumerator.Current
-            {
-                get
-                {
-                    return this.Current;
-                }
-            }
+            object IEnumerator.Current => Current;
 
             public void Dispose()
             {
@@ -469,7 +490,7 @@ public bool MoveNext()
                 {
                     if (LogicalPosition.OnElement == _logicalPosition)
                     {
-                        List<StePermutation> fields = new List<StePermutation>();
+                        List<StePermutation> fields = new();
                         foreach (IEnumerator<StePermutation> field in _fieldEnumerators)
                         {
                             fields.Add(field.Current);
@@ -518,7 +539,7 @@ private void CreateSeparateValueList()
                 int i = 0;
                 foreach (SteSimpleTypeBoundaries field in _parent.ColumnTypes)
                 {
-                    valueSources[i] = field.GetEnumerator(__valueKey);
+                    valueSources[i] = field.GetEnumerator(s_valueKey);
                     valueList[i] = new ArrayList();
                     i++;
                 }
@@ -577,7 +598,7 @@ private void CreateSeparateValueList()
 
             private StePermutation CreateTopLevelPermutation(IList<StePermutation> fields)
             {
-                StePermutation perm = new StePermutation();
+                StePermutation perm = new();
                 if (0 <= _metaDataKeysOfInterest.IndexOf(SteAttributeKey.SqlDbType))
                 {
                     perm.Add(SteAttributeKey.SqlDbType, SqlDbType.Structured);
@@ -629,21 +650,23 @@ static SteStructuredTypeBoundaries()
             AllColumnTypes = new SteStructuredTypeBoundaries(SteSimpleTypeBoundaries.s_allTypes, true);
             UdtsOnly = new SteStructuredTypeBoundaries(SteSimpleTypeBoundaries.s_udtsOnly, true);
 
-            AllTypes = new List<SteStructuredTypeBoundaries>();
-            AllTypes.Add(AllColumnTypes);
-            AllTypes.Add(AllColumnTypesExceptUdts);
-            AllTypes.Add(UdtsOnly);
+            AllTypes = new List<SteStructuredTypeBoundaries>
+            {
+                AllColumnTypes,
+                AllColumnTypesExceptUdts,
+                UdtsOnly
+            };
         }
 
         // instance fields
-        private IList<SteSimpleTypeBoundaries> _columnTypes;
-        private bool _isMultiValued;
+        private readonly IList<SteSimpleTypeBoundaries> _columnTypes;
+        private readonly bool _isMultiValued;
 
         // ctor
         public SteStructuredTypeBoundaries(IList<SteSimpleTypeBoundaries> columnTypes, bool isMultiValued)
         {
             _columnTypes = columnTypes;
-            _isMultiValued = true;
+            _isMultiValued = isMultiValued;
         }
 
         private IList<SteSimpleTypeBoundaries> ColumnTypes
@@ -658,7 +681,7 @@ public override IEnumerable<SteAttributeKey> DefaultKeys
         {
             get
             {
-                List<SteAttributeKey> result = new List<SteAttributeKey>();
+                List<SteAttributeKey> result = new();
                 foreach (SteSimpleTypeBoundaries column in _columnTypes)
                 {
                     foreach (SteAttributeKey columnKey in column.DefaultKeys)
@@ -701,8 +724,7 @@ public override IEnumerator<StePermutation> GetEnumerator(IEnumerable<SteAttribu
 
         public static object[][] GetSeparateValues(IEnumerator<StePermutation> enumerator)
         {
-            SteStructuredTypeBoundariesEnumerator myEnum = enumerator as SteStructuredTypeBoundariesEnumerator;
-            if (null != myEnum)
+            if (enumerator is SteStructuredTypeBoundariesEnumerator myEnum)
             {
                 return myEnum.SeparateValues;
             }
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/StreamInputParam.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/StreamInputParam.cs
index 3d15b4346b..91676446d8 100644
--- a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/StreamInputParam.cs
+++ b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/StreamInputParam.cs
@@ -15,7 +15,7 @@ namespace Microsoft.Data.SqlClient.ManualTesting.Tests
 {
     public static class StreamInputParam
     {
-        private static Random s_rand = new Random(9999);
+        private static readonly Random s_rand = new(9999);
         private static string s_connStr = null;
         private static bool s_useSP = false;
 
@@ -25,12 +25,11 @@ internal class CustomStreamException : Exception
 
         internal class CustomStream : Stream
         {
-            byte[] _data;
-            bool _sync;
+            private readonly byte[] _data;
+            private readonly bool _sync;
             int _pos = 0;
-            int _errorPos = 0;
-
-            Random r = new Random(8888);
+            private readonly int _errorPos = 0;
+            readonly Random _r = new(8888);
 
             public CustomStream(byte[] data, bool sync, int errorPos)
             {
@@ -90,7 +89,7 @@ private int ReadInternal(byte[] buffer, int offset, int count)
                 }
                 else
                 {
-                    nRead = 1 + r.Next(Math.Min(count, _data.Length - _pos) - 1);
+                    nRead = 1 + _r.Next(Math.Min(count, _data.Length - _pos) - 1);
                 }
                 if (_errorPos >= _pos && _errorPos < _pos + nRead)
                     throw new CustomStreamException();
@@ -108,7 +107,7 @@ public override int Read(byte[] buffer, int offset, int count)
             public override Task<int> ReadAsync(byte[] buffer, int offset, int count, System.Threading.CancellationToken cancellationToken)
             {
                 Debug.Assert(!_sync, "Custom stream reader: Async read in sync mode");
-                TaskCompletionSource<int> tcs = new TaskCompletionSource<int>();
+                TaskCompletionSource<int> tcs = new();
                 tcs.SetResult(ReadInternal(buffer, offset, count));
                 return tcs.Task;
             }
@@ -158,98 +157,103 @@ private static void TestCustomStream(int dataLen, bool sync, bool oldTypes, int
 
         private static void TestStreamHelper(byte[] val, object stream, bool sync, bool oldTypes, int paramLen, bool expectException, bool addWithValue)
         {
-            using (SqlConnection conn = new SqlConnection(s_connStr))
+            using SqlConnection conn = new(s_connStr);
+            conn.Open();
+            using SqlCommand command = new()
             {
-                conn.Open();
-                (new SqlCommand("create table #blobs (id INT, blob VARBINARY(MAX))", conn)).ExecuteNonQuery();
-                try
+                CommandText = "create table #blobs (id INT, blob VARBINARY(MAX))",
+                Connection = conn
+            };
+            _ = command.ExecuteNonQuery();
+            try
+            {
+                SqlCommand ins;
+                if (!s_useSP)
+                {
+                    ins = new SqlCommand("insert into #blobs (id,blob) values (1,@blob)", conn);
+                }
+                else
                 {
-                    SqlCommand ins;
-                    if (!s_useSP)
+                    new SqlCommand("create procedure #myProc (@blob varbinary(MAX)) as begin insert into #blobs values (1, @blob) end", conn).ExecuteNonQuery();
+                    ins = new SqlCommand("#myProc", conn)
                     {
-                        ins = new SqlCommand("insert into #blobs (id,blob) values (1,@blob)", conn);
-                    }
-                    else
+                        CommandType = CommandType.StoredProcedure
+                    };
+                }
+                if (addWithValue)
+                {
+                    ins.Parameters.AddWithValue("@blob", stream);
+                }
+                else
+                {
+                    ins.Parameters.Add("@blob", oldTypes ? SqlDbType.Image : SqlDbType.VarBinary, paramLen);
+                    ins.Parameters["@blob"].Direction = ParameterDirection.Input;
+                    ins.Parameters["@blob"].Value = stream;
+                }
+                bool exc = false;
+                if (sync)
+                {
+                    try
                     {
-                        new SqlCommand("create procedure #myProc (@blob varbinary(MAX)) as begin insert into #blobs values (1, @blob) end", conn).ExecuteNonQuery();
-                        ins = new SqlCommand("#myProc", conn);
-                        ins.CommandType = CommandType.StoredProcedure;
+                        ins.ExecuteNonQuery();
                     }
-                    if (addWithValue)
+                    catch (CustomStreamException)
                     {
-                        ins.Parameters.AddWithValue("@blob", stream);
+                        exc = true;
                     }
-                    else
+                }
+                else
+                {
+                    try
                     {
-                        ins.Parameters.Add("@blob", oldTypes ? SqlDbType.Image : SqlDbType.VarBinary, paramLen);
-                        ins.Parameters["@blob"].Direction = ParameterDirection.Input;
-                        ins.Parameters["@blob"].Value = stream;
+                        ins.ExecuteNonQueryAsync().Wait();
                     }
-                    bool exc = false;
-                    if (sync)
+                    catch (AggregateException ae)
                     {
-                        try
-                        {
-                            ins.ExecuteNonQuery();
-                        }
-                        catch (CustomStreamException)
+                        if (ae.InnerException is CustomStreamException)
                         {
                             exc = true;
                         }
-                    }
-                    else
-                    {
-                        try
-                        {
-                            ins.ExecuteNonQueryAsync().Wait();
-                        }
-                        catch (AggregateException ae)
+                        else
                         {
-                            if (ae.InnerException is CustomStreamException)
-                            {
-                                exc = true;
-                            }
-                            else
-                            {
-                                throw;
-                            }
+                            throw;
                         }
                     }
-                    Debug.Assert(exc == expectException, "Exception!=Expectation");
+                }
+                Debug.Assert(exc == expectException, "Exception!=Expectation");
 
-                    byte[] back = (new SqlCommand("select blob from #blobs where id=1", conn)).ExecuteScalar() as byte[];
-                    if (!expectException)
-                    {
-                        AssertEqual(back, val, paramLen);
-                    }
+                byte[] back = (new SqlCommand("select blob from #blobs where id=1", conn)).ExecuteScalar() as byte[];
+                if (!expectException)
+                {
+                    AssertEqual(back, val, paramLen);
                 }
-                finally
+            }
+            finally
+            {
+                (new SqlCommand("drop table #blobs", conn)).ExecuteNonQuery();
+                if (s_useSP)
                 {
-                    (new SqlCommand("drop table #blobs", conn)).ExecuteNonQuery();
-                    if (s_useSP)
-                    {
-                        (new SqlCommand("drop procedure #myProc", conn)).ExecuteNonQuery();
-                    }
+                    (new SqlCommand("drop procedure #myProc", conn)).ExecuteNonQuery();
                 }
             }
         }
 
-        private static string _xmlstr = null;
+        private static string s_xmlstr = null;
 
         private static string XmlStr
         {
             get
             {
-                if (_xmlstr == null)
+                if (s_xmlstr == null)
                 {
                     int N = 10000;
-                    XmlDocument doc = new XmlDocument();
+                    XmlDocument doc = new();
                     XmlNode root = doc.AppendChild(doc.CreateElement("root"));
                     for (int i = 0; i < N; i++)
                         root.AppendChild(doc.CreateElement("e" + i.ToString()));
-                    _xmlstr = doc.OuterXml;
+                    s_xmlstr = doc.OuterXml;
                 }
-                return _xmlstr;
+                return s_xmlstr;
             }
         }
 
@@ -261,7 +265,7 @@ private static void TestXml2Text(bool sync, bool oldTypes, int paramLen, bool nv
 
         private static void TestTextReader(int dataLen, bool sync, bool oldTypes, int paramLen, bool nvarchar, bool addWithValue = false)
         {
-            StringBuilder sb = new StringBuilder();
+            StringBuilder sb = new();
             for (int i = 0; i < dataLen; i++)
                 sb.Append((char)('A' + s_rand.Next(20)));
             string s = sb.ToString();
@@ -271,7 +275,7 @@ private static void TestTextReader(int dataLen, bool sync, bool oldTypes, int pa
 
         private static void TestCustomTextReader(int dataLen, bool sync, bool oldTypes, int paramLen, bool nvarchar, bool error, bool addWithValue = false)
         {
-            StringBuilder sb = new StringBuilder();
+            StringBuilder sb = new();
             for (int i = 0; i < dataLen; i++)
                 sb.Append((char)('A' + s_rand.Next(20)));
             string s = sb.ToString();
@@ -284,88 +288,92 @@ private static void TestCustomTextReader(int dataLen, bool sync, bool oldTypes,
 
         private static void TestTextWrite(string s, object reader, bool sync, bool oldTypes, int paramLen, bool nvarchar, bool expectException, bool addWithValue)
         {
-            using (SqlConnection conn = new SqlConnection(s_connStr))
+            using SqlConnection conn = new(s_connStr);
+            conn.Open();
+            SqlCommand command = new()
             {
-                conn.Open();
-
-                (new SqlCommand(string.Format("create table #blobs (id INT, blob {0}(MAX))", nvarchar ? "NVARCHAR" : "VARCHAR"), conn)).ExecuteNonQuery();
-                try
+                Connection = conn,
+                CommandText = $"create table #blobs (id INT, blob {(nvarchar ? "NVARCHAR" : "VARCHAR")}(MAX))"
+            };
+            _ = command.ExecuteNonQuery();
+            try
+            {
+                SqlCommand ins;
+                if (!s_useSP)
                 {
-                    SqlCommand ins;
-                    if (!s_useSP)
+                    ins = new SqlCommand("insert into #blobs (id,blob) values (1,@blob)", conn);
+                }
+                else
+                {
+                    new SqlCommand(
+                        string.Format("create procedure #myProc (@blob {0}(MAX)) as begin insert into #blobs values (1, @blob) end", nvarchar ? "NVARCHAR" : "VARCHAR"),
+                        conn).ExecuteNonQuery();
+                    ins = new SqlCommand("#myProc", conn)
                     {
-                        ins = new SqlCommand("insert into #blobs (id,blob) values (1,@blob)", conn);
-                    }
-                    else
+                        CommandType = CommandType.StoredProcedure
+                    };
+                }
+                if (addWithValue)
+                {
+                    ins.Parameters.AddWithValue("@blob", reader);
+                }
+                else
+                {
+                    ins.Parameters.Add("@blob", nvarchar ?
+                                                   (oldTypes ? SqlDbType.NText : SqlDbType.NVarChar) :
+                                                   (oldTypes ? SqlDbType.Text : SqlDbType.VarChar), paramLen);
+                    ins.Parameters["@blob"].Direction = ParameterDirection.Input;
+                    ins.Parameters["@blob"].Value = reader;
+                }
+
+                bool exc = false;
+                if (sync)
+                {
+                    try
                     {
-                        new SqlCommand(
-                            string.Format("create procedure #myProc (@blob {0}(MAX)) as begin insert into #blobs values (1, @blob) end", nvarchar ? "NVARCHAR" : "VARCHAR"),
-                            conn).ExecuteNonQuery();
-                        ins = new SqlCommand("#myProc", conn);
-                        ins.CommandType = CommandType.StoredProcedure;
+                        ins.ExecuteNonQuery();
                     }
-                    if (addWithValue)
+                    catch (CustomStreamException)
                     {
-                        ins.Parameters.AddWithValue("@blob", reader);
+                        exc = true;
                     }
-                    else
+                }
+                else
+                {
+                    try
                     {
-                        ins.Parameters.Add("@blob", nvarchar ?
-                                                       (oldTypes ? SqlDbType.NText : SqlDbType.NVarChar) :
-                                                       (oldTypes ? SqlDbType.Text : SqlDbType.VarChar), paramLen);
-                        ins.Parameters["@blob"].Direction = ParameterDirection.Input;
-                        ins.Parameters["@blob"].Value = reader;
+                        ins.ExecuteNonQueryAsync().Wait();
                     }
-
-                    bool exc = false;
-                    if (sync)
+                    catch (AggregateException ae)
                     {
-                        try
-                        {
-                            ins.ExecuteNonQuery();
-                        }
-                        catch (CustomStreamException)
+                        if (ae.InnerException is CustomStreamException)
                         {
                             exc = true;
                         }
-                    }
-                    else
-                    {
-                        try
+                        else
                         {
-                            ins.ExecuteNonQueryAsync().Wait();
-                        }
-                        catch (AggregateException ae)
-                        {
-                            if (ae.InnerException is CustomStreamException)
-                            {
-                                exc = true;
-                            }
-                            else
-                            {
-                                throw;
-                            }
+                            throw;
                         }
                     }
-                    Debug.Assert(exc == expectException, "Exception!=Expectation");
+                }
+                Debug.Assert(exc == expectException, "Exception!=Expectation");
 
-                    string back = (new SqlCommand("select blob from #blobs where id=1", conn)).ExecuteScalar() as string;
-                    if (paramLen > 0)
-                    {
-                        s = s.Substring(0, Math.Min(paramLen, s.Length));
-                    }
-                    if (!expectException)
-                    {
-                        Debug.Assert(back == s, "Strings are not equal");
-                    }
+                string back = (new SqlCommand("select blob from #blobs where id=1", conn)).ExecuteScalar() as string;
+                if (paramLen > 0)
+                {
+                    s = s.Substring(0, Math.Min(paramLen, s.Length));
                 }
-                finally
+                if (!expectException)
                 {
-                    (new SqlCommand("drop table #blobs", conn)).ExecuteNonQuery();
-                    if (s_useSP)
-                    {
-                        (new SqlCommand("drop procedure #myProc", conn)).ExecuteNonQuery();
-                    }
+                    Debug.Assert(back == s, "Strings are not equal");
+                }
+            }
+            finally
+            {
+                (new SqlCommand("drop table #blobs", conn)).ExecuteNonQuery();
+                if (s_useSP)
+                {
+                    (new SqlCommand("drop procedure #myProc", conn)).ExecuteNonQuery();
                 }
             }
         }
@@ -373,160 +381,167 @@ private static void TestTextWrite(string s, object reader, bool sync, bool oldTy
         private static void TestXML(bool sync, bool lengthLimited, bool addWithValue = false)
         {
 
-            using (SqlConnection conn = new SqlConnection(s_connStr))
+            using SqlConnection conn = new(s_connStr);
+            conn.Open();
+            SqlCommand command = new()
             {
-                conn.Open();
-
-                (new SqlCommand("create table #blobs (id INT, blob XML)", conn)).ExecuteNonQuery();
-                try
+                Connection = conn,
+                CommandText = "create table #blobs (id INT, blob XML)"
+            };
+            _ = command.ExecuteNonQuery();
+            try
+            {
+                SqlCommand ins;
+                if (!s_useSP)
                 {
-                    SqlCommand ins;
-                    if (!s_useSP)
-                    {
-                        ins = new SqlCommand("insert into #blobs (id,blob) values (1,@blob)", conn);
-                    }
-                    else
+                    ins = new SqlCommand("insert into #blobs (id,blob) values (1,@blob)", conn);
+                }
+                else
+                {
+                    new SqlCommand("create procedure #myProc (@blob XML) as begin insert into #blobs values (1, @blob) end", conn).ExecuteNonQuery();
+                    ins = new SqlCommand("#myProc", conn)
                     {
-                        new SqlCommand("create procedure #myProc (@blob XML) as begin insert into #blobs values (1, @blob) end", conn).ExecuteNonQuery();
-                        ins = new SqlCommand("#myProc", conn);
-                        ins.CommandType = CommandType.StoredProcedure;
-                    }
+                        CommandType = CommandType.StoredProcedure
+                    };
+                }
 
-                    StringBuilder comment = new StringBuilder();
-                    if (lengthLimited)
-                    {
-                        comment.Append("<!-- ");
-                        int N = s_rand.Next(100);
-                        for (int i = 0; i < N; i++)
-                            comment.Append(i.ToString());
-                        comment.Append("-->");
-                    }
-                    XmlReader reader = XmlReader.Create(new StringReader(XmlStr + comment.ToString()));
+                StringBuilder comment = new();
+                if (lengthLimited)
+                {
+                    comment.Append("<!-- ");
+                    int N = s_rand.Next(100);
+                    for (int i = 0; i < N; i++)
+                        comment.Append(i.ToString());
+                    comment.Append("-->");
+                }
+                XmlReader reader = XmlReader.Create(new StringReader(XmlStr + comment.ToString()));
 
-                    if (addWithValue)
-                    {
-                        ins.Parameters.AddWithValue("@blob", reader);
-                    }
-                    else
-                    {
-                        ins.Parameters.Add("@blob", SqlDbType.Xml, lengthLimited ? XmlStr.Length : -1);
-                        ins.Parameters["@blob"].Direction = ParameterDirection.Input;
-                        ins.Parameters["@blob"].Value = reader;
-                    }
-                    if (sync)
-                    {
-                        ins.ExecuteNonQuery();
-                    }
-                    else
-                    {
-                        ins.ExecuteNonQueryAsync().Wait();
-                    }
-                    string back = (new SqlCommand("select blob from #blobs where id=1", conn)).ExecuteScalar() as string;
-                    Debug.Assert(back == XmlStr, "String!=xml");
-                    if (back != XmlStr)
-                    {
-                        Console.WriteLine("[{0}]", back);
-                        Console.WriteLine("[{0}]", XmlStr);
-                    }
+                if (addWithValue)
+                {
+                    ins.Parameters.AddWithValue("@blob", reader);
                 }
-                finally
+                else
                 {
-                    (new SqlCommand("drop table #blobs", conn)).ExecuteNonQuery();
-                    if (s_useSP)
-                    {
-                        (new SqlCommand("drop procedure #myProc", conn)).ExecuteNonQuery();
-                    }
+                    ins.Parameters.Add("@blob", SqlDbType.Xml, lengthLimited ? XmlStr.Length : -1);
+                    ins.Parameters["@blob"].Direction = ParameterDirection.Input;
+                    ins.Parameters["@blob"].Value = reader;
+                }
+                if (sync)
+                {
+                    ins.ExecuteNonQuery();
+                }
+                else
+                {
+                    ins.ExecuteNonQueryAsync().Wait();
+                }
+                SqlCommand stringCommand = new()
+                {
+                    Connection = conn,
+                    CommandText = "select blob from #blobs where id=1"
+                };
+                string back = stringCommand.ExecuteScalar() as string;
+                Debug.Assert(back == XmlStr, "String!=xml");
+                if (back != XmlStr)
+                {
+                    Console.WriteLine("[{0}]", back);
+                    Console.WriteLine("[{0}]", XmlStr);
+                }
+            }
+            finally
+            {
+                using SqlCommand dropCommand = new()
+                {
+                    Connection = conn,
+                    CommandText = "drop table #blobs"
+                };
+                dropCommand.ExecuteNonQuery();
+                if (s_useSP)
+                {
+                    dropCommand.CommandText = "drop procedure #myProc";
+                    dropCommand.ExecuteNonQuery();
                 }
-                Console.WriteLine("TestXml (Sync {0} LimitLength {1} ) is OK", sync, lengthLimited);
             }
+            Console.WriteLine("TestXml (Sync {0} LimitLength {1} ) is OK", sync, lengthLimited);
         }
 
         private static void ImmediateCancelBin()
         {
             Console.WriteLine("Test immediate cancel for binary stream");
-            CancellationTokenSource cts = new CancellationTokenSource();
-            using (SqlConnection conn = new SqlConnection(s_connStr))
+            CancellationTokenSource cts = new();
+            using SqlConnection conn = new(s_connStr);
+            conn.OpenAsync().Wait();
+            using SqlCommand cmd = conn.CreateCommand();
+            cmd.CommandText = "create table #blobs (Id int, blob varbinary(max))";
+            cmd.ExecuteNonQuery();
+            Random rand = new(10000);
+            int dataSize = 10000000;
+            byte[] data = new byte[dataSize];
+            rand.NextBytes(data);
+            MemoryStream ms = new(data, false);
+            // Include a delay to allow time for cancellation
+            cmd.CommandText = "WAITFOR DELAY '00:00:05'; insert into #blobs (Id, blob) values (1, @blob)";
+            cmd.Parameters.Add("@blob", SqlDbType.VarBinary, dataSize);
+            cmd.Parameters["@blob"].Direction = ParameterDirection.Input;
+            cmd.Parameters["@blob"].Value = ms;
+
+            try
             {
-                conn.OpenAsync().Wait();
-                using (SqlCommand cmd = conn.CreateCommand())
-                {
-                    cmd.CommandText = "create table #blobs (Id int, blob varbinary(max))";
-                    cmd.ExecuteNonQuery();
-                    Random rand = new Random(10000);
-                    int dataSize = 10000000;
-                    byte[] data = new byte[dataSize];
-                    rand.NextBytes(data);
-                    MemoryStream ms = new MemoryStream(data, false);
-                    // Include a delay to allow time for cancellation
-                    cmd.CommandText = "WAITFOR DELAY '00:00:05'; insert into #blobs (Id, blob) values (1, @blob)";
-                    cmd.Parameters.Add("@blob", SqlDbType.VarBinary, dataSize);
-                    cmd.Parameters["@blob"].Direction = ParameterDirection.Input;
-                    cmd.Parameters["@blob"].Value = ms;
-
-                    try
-                    {
-                        Task.WaitAll(cmd.ExecuteNonQueryAsync(cts.Token), Task.Run(() => cts.Cancel()));
-                        Console.WriteLine("FAIL: Expected AggregateException on Task wait for Cancelled Task!");
-                    }
-                    catch (AggregateException ae)
-                    {
-                        if (ae.InnerException is InvalidOperationException ||
-                            (ae.InnerException is SqlException &&
-                             ae.InnerException.Message.Contains("Operation cancelled by user.")))
-                        {
-                            Console.WriteLine("PASS: Task is cancelled");
-                        }
-                        else
-                        {
-                            throw ae.InnerException;
-                        }
-                    }
-                    finally
-                    {
-                        ms.Close();
-                    }
+                Task.WaitAll(cmd.ExecuteNonQueryAsync(cts.Token), Task.Run(() => cts.Cancel()));
+                Console.WriteLine("FAIL: Expected AggregateException on Task wait for Cancelled Task!");
+            }
+            catch (AggregateException ae)
+            {
+                if (ae.InnerException is InvalidOperationException ||
+                    (ae.InnerException is SqlException &&
+                     ae.InnerException.Message.Contains("Operation cancelled by user.")))
+                {
+                    Console.WriteLine("PASS: Task is cancelled");
                 }
+                else
+                {
+                    throw ae.InnerException;
+                }
+            }
+            finally
+            {
+                ms.Close();
             }
         }
 
         private static void ImmediateCancelText()
         {
             Console.WriteLine("Test immediate cancel for text stream");
-            CancellationTokenSource cts = new CancellationTokenSource();
-            using (SqlConnection conn = new SqlConnection(s_connStr))
+            CancellationTokenSource cts = new();
+            using SqlConnection conn = new(s_connStr);
+            conn.OpenAsync().Wait();
+            using SqlCommand cmd = conn.CreateCommand();
+            cmd.CommandText = "create table #blobs (Id int, blob varchar(max))";
+            cmd.ExecuteNonQuery();
+            StringBuilder sb = new();
+            for (int i = 0; i < 1000000; i++)
+                sb.Append(i);
+            // Include a delay to allow time for cancellation
+            cmd.CommandText = "WAITFOR DELAY '00:00:05'; insert into #blobs (Id, blob) values (1, @blob)";
+            cmd.Parameters.Add("@blob", SqlDbType.VarChar, -1);
+            cmd.Parameters["@blob"].Direction = ParameterDirection.Input;
+            cmd.Parameters["@blob"].Value = new StringReader(sb.ToString());
+
+            try
             {
-                conn.OpenAsync().Wait();
-                using (SqlCommand cmd = conn.CreateCommand())
-                {
-                    cmd.CommandText = "create table #blobs (Id int, blob varchar(max))";
-                    cmd.ExecuteNonQuery();
-                    StringBuilder sb = new StringBuilder();
-                    for (int i = 0; i < 1000000; i++)
-                        sb.Append(i);
-                    // Include a delay to allow time for cancellation
-                    cmd.CommandText = "WAITFOR DELAY '00:00:05'; insert into #blobs (Id, blob) values (1, @blob)";
-                    cmd.Parameters.Add("@blob", SqlDbType.VarChar, -1);
-                    cmd.Parameters["@blob"].Direction = ParameterDirection.Input;
-                    cmd.Parameters["@blob"].Value = new StringReader(sb.ToString());
-
-                    try
-                    {
-                        Task.WaitAll(cmd.ExecuteNonQueryAsync(cts.Token), Task.Run(() => cts.Cancel()));
-                        Console.WriteLine("FAIL: Expected AggregateException on Task wait for Cancelled Task!");
-                    }
-                    catch (AggregateException ae)
-                    {
-                        if (ae.InnerException is InvalidOperationException ||
-                            (ae.InnerException is SqlException &&
-                             ae.InnerException.Message.Contains("Operation cancelled by user.")))
-                        {
-                            Console.WriteLine("PASS: Task is cancelled");
-                        }
-                        else
-                        {
-                            throw ae.InnerException;
-                        }
-                    }
+                Task.WaitAll(cmd.ExecuteNonQueryAsync(cts.Token), Task.Run(() => cts.Cancel()));
+                Console.WriteLine("FAIL: Expected AggregateException on Task wait for Cancelled Task!");
+            }
+            catch (AggregateException ae)
+            {
+                if (ae.InnerException is InvalidOperationException ||
+                    (ae.InnerException is SqlException &&
+                     ae.InnerException.Message.Contains("Operation cancelled by user.")))
+                {
+                    Console.WriteLine("PASS: Task is cancelled");
+                }
+                else
+                {
+                    throw ae.InnerException;
                 }
             }
         }
@@ -534,38 +549,34 @@ private static void ImmediateCancelText()
         private static void ImmediateCancelXml()
         {
             Console.WriteLine("Test immediate cancel for xml stream");
-            CancellationTokenSource cts = new CancellationTokenSource();
-            using (SqlConnection conn = new SqlConnection(s_connStr))
+            CancellationTokenSource cts = new();
+            using SqlConnection conn = new(s_connStr);
+            conn.OpenAsync().Wait();
+            using SqlCommand cmd = conn.CreateCommand();
+            cmd.CommandText = "create table #blobs (Id int, blob xml)";
+            cmd.ExecuteNonQuery();
+            // Include a delay to allow time for cancellation
+            cmd.CommandText = "WAITFOR DELAY '00:00:05'; insert into #blobs (Id, blob) values (1, @blob)";
+            cmd.Parameters.Add("@blob", SqlDbType.Xml, -1);
+            cmd.Parameters["@blob"].Direction = ParameterDirection.Input;
+            cmd.Parameters["@blob"].Value = XmlReader.Create(new StringReader(XmlStr));
+
+            try
             {
-                conn.OpenAsync().Wait();
-                using (SqlCommand cmd = conn.CreateCommand())
+                Task.WaitAll(cmd.ExecuteNonQueryAsync(cts.Token), Task.Run(() => cts.Cancel()));
+                Console.WriteLine("FAIL: Expected AggregateException on Task wait for Cancelled Task!");
+            }
+            catch (AggregateException ae)
+            {
+                if (ae.InnerException is InvalidOperationException ||
+                    (ae.InnerException is SqlException &&
+                     ae.InnerException.Message.Contains("Operation cancelled by user.")))
                 {
-                    cmd.CommandText = "create table #blobs (Id int, blob xml)";
-                    cmd.ExecuteNonQuery();
-                    // Include a delay to allow time for cancellation
-                    cmd.CommandText = "WAITFOR DELAY '00:00:05'; insert into #blobs (Id, blob) values (1, @blob)";
-                    cmd.Parameters.Add("@blob", SqlDbType.Xml, -1);
-                    cmd.Parameters["@blob"].Direction = ParameterDirection.Input;
-                    cmd.Parameters["@blob"].Value = XmlReader.Create(new StringReader(XmlStr));
-
-                    try
-                    {
-                        Task.WaitAll(cmd.ExecuteNonQueryAsync(cts.Token), Task.Run(() => cts.Cancel()));
-                        Console.WriteLine("FAIL: Expected AggregateException on Task wait for Cancelled Task!");
-                    }
-                    catch (AggregateException ae)
-                    {
-                        if (ae.InnerException is InvalidOperationException ||
-                            (ae.InnerException is SqlException &&
-                             ae.InnerException.Message.Contains("Operation cancelled by user.")))
-                        {
-                            Console.WriteLine("PASS: Task is cancelled");
-                        }
-                        else
-                        {
-                            throw ae.InnerException;
-                        }
-                    }
+                    Console.WriteLine("PASS: Task is cancelled");
+                }
+                else
+                {
+                    throw ae.InnerException;
                 }
             }
         }
@@ -573,83 +584,77 @@ private static void ImmediateCancelXml()
         private static void PrepareCommand()
         {
             Console.Write("Test command preparation ");
-            using (SqlConnection conn = new SqlConnection(s_connStr))
+            using (SqlConnection conn = new(s_connStr))
             {
                 conn.Open();
-                using (SqlCommand cmd = conn.CreateCommand())
-                {
-                    cmd.CommandText = "create table #blobs (Id int, blob varbinary(max))";
-                    cmd.ExecuteNonQuery();
-                    Random rand = new Random(10000);
-                    int dataSize = 100000;
-                    byte[] data = new byte[dataSize];
-                    rand.NextBytes(data);
-                    MemoryStream ms = new MemoryStream(data, false);
-
-                    cmd.CommandText = "insert into #blobs (Id, blob) values (1, @blob)";
-
-                    cmd.Parameters.Add("@blob", SqlDbType.VarBinary, dataSize);
-                    cmd.Parameters["@blob"].Direction = ParameterDirection.Input;
-                    cmd.Parameters["@blob"].Value = ms;
-                    cmd.Prepare();
-                    cmd.ExecuteNonQuery();
-                    conn.Close();
-                    ms.Close();
-                }
+                using SqlCommand cmd = conn.CreateCommand();
+                cmd.CommandText = "create table #blobs (Id int, blob varbinary(max))";
+                cmd.ExecuteNonQuery();
+                Random rand = new(10000);
+                int dataSize = 100000;
+                byte[] data = new byte[dataSize];
+                rand.NextBytes(data);
+                MemoryStream ms = new(data, false);
+
+                cmd.CommandText = "insert into #blobs (Id, blob) values (1, @blob)";
+
+                cmd.Parameters.Add("@blob", SqlDbType.VarBinary, dataSize);
+                cmd.Parameters["@blob"].Direction = ParameterDirection.Input;
+                cmd.Parameters["@blob"].Value = ms;
+                cmd.Prepare();
+                cmd.ExecuteNonQuery();
+                conn.Close();
+                ms.Close();
             }
             Console.WriteLine("PASS");
         }
 
         private static void CommandReuse()
         {
-            foreach (var func in new Func<SqlCommand, CancellationToken, Task>[] {
+            foreach (Func<SqlCommand, CancellationToken, Task> func in new Func<SqlCommand, CancellationToken, Task>[] {
                     (cmd,token) => cmd.ExecuteNonQueryAsync(token),
                     (cmd,token) => cmd.ExecuteReaderAsync(token),
                     (cmd,token) => cmd.ExecuteXmlReaderAsync(token)
             })
             {
-                CancellationTokenSource cts = new CancellationTokenSource();
-                using (SqlConnection conn = new SqlConnection(s_connStr))
+                CancellationTokenSource cts = new();
+                using SqlConnection conn = new(s_connStr);
+                conn.OpenAsync().Wait();
+                Console.WriteLine("Test reuse of command after cancel");
+                using SqlCommand cmd = conn.CreateCommand();
+                cmd.CommandText = "create table #blobs (Id int, blob varbinary(max))";
+                cmd.ExecuteNonQuery();
+                Random rand = new(10000);
+                int dataSize = 100000;
+                byte[] binarydata = new byte[dataSize];
+                rand.NextBytes(binarydata);
+                MemoryStream ms = new(binarydata, false);
+                // Include a delay to allow time for cancellation
+                cmd.CommandText = "WAITFOR DELAY '00:00:05'; insert into #blobs (Id, blob) values (1, @blob)";
+
+                cmd.Parameters.Add("@blob", SqlDbType.VarBinary, dataSize);
+                cmd.Parameters["@blob"].Direction = ParameterDirection.Input;
+                cmd.Parameters["@blob"].Value = ms;
+
+                try
                 {
-                    conn.OpenAsync().Wait();
-                    Console.WriteLine("Test reuse of command after cancel");
-                    using (SqlCommand cmd = conn.CreateCommand())
+                    Task.WaitAll(func(cmd, cts.Token), Task.Run(() => cts.Cancel()));
+                    Console.WriteLine("FAIL: Expected AggregateException on Task wait for Cancelled Task!");
+                }
+                catch (AggregateException ae)
+                {
+                    if (!ae.InnerException.Message.Contains("Operation cancelled by user."))
                     {
-                        cmd.CommandText = "create table #blobs (Id int, blob varbinary(max))";
-                        cmd.ExecuteNonQuery();
-                        Random rand = new Random(10000);
-                        int dataSize = 100000;
-                        byte[] binarydata = new byte[dataSize];
-                        rand.NextBytes(binarydata);
-                        MemoryStream ms = new MemoryStream(binarydata, false);
-                        // Include a delay to allow time for cancellation
-                        cmd.CommandText = "WAITFOR DELAY '00:00:05'; insert into #blobs (Id, blob) values (1, @blob)";
-
-                        cmd.Parameters.Add("@blob", SqlDbType.VarBinary, dataSize);
-                        cmd.Parameters["@blob"].Direction = ParameterDirection.Input;
-                        cmd.Parameters["@blob"].Value = ms;
-
-                        try
-                        {
-                            Task.WaitAll(func(cmd, cts.Token), Task.Run(() => cts.Cancel()));
-                            Console.WriteLine("FAIL: Expected AggregateException on Task wait for Cancelled Task!");
-                        }
-                        catch (AggregateException ae)
-                        {
-                            if (!ae.InnerException.Message.Contains("Operation cancelled by user."))
-                            {
-                                Console.WriteLine("FAIL: Unexpected exception message: " + ae.InnerException.Message);
-                            }
-                        }
-                        finally
-                        {
-                            ms.Close();
-                        }
-                        cmd.Parameters.Clear();
-                        cmd.CommandText = "select 'PASS'";
-                        Console.WriteLine(cmd.ExecuteScalar());
+                        Console.WriteLine("FAIL: Unexpected exception message: " + ae.InnerException.Message);
                     }
                 }
+                finally
+                {
+                    ms.Close();
+                }
+                cmd.Parameters.Clear();
+                cmd.CommandText = "select 'PASS'";
+                Console.WriteLine(cmd.ExecuteScalar());
             }
         }
 
@@ -665,7 +670,7 @@ internal static void Run(string connection)
                 bool oldTypes = false;
                 do
                 {
-                    using (AsyncDebugScope debugScope = new AsyncDebugScope())
+                    using (AsyncDebugScope debugScope = new())
                     {
                         for (int run = 0; run < 2; run++)
                         {
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/TvpTest.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/TvpTest.cs
index 084fe11789..4c7f198793 100644
--- a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/TvpTest.cs
+++ b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ParameterTest/TvpTest.cs
@@ -24,7 +24,7 @@ namespace Microsoft.Data.SqlClient.ManualTesting.Tests
     public class TvpTest
     {
         private const string TvpName = "@tvp";
-        private static readonly IList<SteAttributeKey> BoundariesTestKeys = new List<SteAttributeKey>(
+        private static readonly IList<SteAttributeKey> s_boundariesTestKeys = new List<SteAttributeKey>(
                 new SteAttributeKey[] {
                     SteAttributeKey.SqlDbType,
                     SteAttributeKey.MultiValued,
@@ -40,7 +40,7 @@ public class TvpTest
                 }).AsReadOnly();
 
         // data value and server consts
-        private string _connStr;
+        private readonly string _connStr;
 
         // Synapse: The statement failed. Column 'blob' has a data type that cannot participate in a columnstore index.
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureSynapse))]
@@ -66,7 +66,7 @@ public void TestPacketNumberWraparound()
 
             var enumerator = new WraparoundRowEnumerator(1000000);
 
-            Stopwatch stopwatch = new Stopwatch();
+            Stopwatch stopwatch = new();
             stopwatch.Start();
             int returned = Task.WaitAny(
                 Task.Factory.StartNew(
@@ -214,7 +214,7 @@ private bool RunTestCoreAndCompareWithBaseline()
             Console.Out.Dispose();
 
             // Recover the standard output stream
-            StreamWriter standardOutput = new StreamWriter(Console.OpenStandardOutput());
+            StreamWriter standardOutput = new(Console.OpenStandardOutput());
             standardOutput.AutoFlush = true;
             Console.SetOut(standardOutput);
 
@@ -288,10 +288,7 @@ private sealed class CarriageReturnLineFeedReplacer : TextWriter
 
             internal CarriageReturnLineFeedReplacer(TextWriter output)
             {
-                if (output == null)
-                    throw new ArgumentNullException(nameof(output));
-
-                _output = output;
+                _output = output ?? throw new ArgumentNullException(nameof(output));
             }
 
             public int LineFeedCount
@@ -347,8 +344,8 @@ public override void Write(char value)
         #region Main test methods
         private void ColumnBoundariesTest()
         {
-            IEnumerator<StePermutation> boundsMD = SteStructuredTypeBoundaries.AllColumnTypesExceptUdts.GetEnumerator(
-                        BoundariesTestKeys);
+            _ = SteStructuredTypeBoundaries.AllColumnTypesExceptUdts.GetEnumerator(
+                        s_boundariesTestKeys);
             TestTVPPermutations(SteStructuredTypeBoundaries.AllColumnTypesExceptUdts, false);
             //Console.WriteLine("+++++++++++  UDT TVP tests ++++++++++++++");
             //TestTVPPermutations(SteStructuredTypeBoundaries.UdtsOnly, true);
@@ -356,12 +353,12 @@ private void ColumnBoundariesTest()
 
         private void TestTVPPermutations(SteStructuredTypeBoundaries bounds, bool runOnlyDataRecordTest)
         {
-            IEnumerator<StePermutation> boundsMD = bounds.GetEnumerator(BoundariesTestKeys);
+            IEnumerator<StePermutation> boundsMD = bounds.GetEnumerator(s_boundariesTestKeys);
 
             object[][] baseValues = SteStructuredTypeBoundaries.GetSeparateValues(boundsMD);
             IList<DataTable> dtList = GenerateDataTables(baseValues);
 
-            TransactionOptions opts = new TransactionOptions();
+            TransactionOptions opts = new();
             opts.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
 
             // for each unique pattern of metadata
@@ -374,8 +371,10 @@ private void TestTVPPermutations(SteStructuredTypeBoundaries bounds, bool runOnl
                 // Set up base command
                 SqlCommand cmd;
                 SqlParameter param;
-                cmd = new SqlCommand(GetProcName(tvpPerm));
-                cmd.CommandType = CommandType.StoredProcedure;
+                cmd = new SqlCommand(GetProcName(tvpPerm))
+                {
+                    CommandType = CommandType.StoredProcedure
+                };
                 param = cmd.Parameters.Add(TvpName, SqlDbType.Structured);
                 param.TypeName = GetTypeName(tvpPerm);
 
@@ -438,268 +437,263 @@ private void TestTVPPermutations(SteStructuredTypeBoundaries bounds, bool runOnl
 
         private void QueryHintsTest()
         {
-            using (SqlConnection conn = new SqlConnection(_connStr))
-            {
-                conn.Open();
-
-                Guid randomizer = Guid.NewGuid();
-                string typeName = string.Format("dbo.[QHint_{0}]", randomizer);
-                string procName = string.Format("dbo.[QHint_Proc_{0}]", randomizer);
-                string createTypeSql = string.Format(
-                        "CREATE TYPE {0} AS TABLE("
-                            + " c1 Int DEFAULT -1,"
-                            + " c2 NVarChar(40) DEFAULT N'DEFUALT',"
-                            + " c3 DateTime DEFAULT '1/1/2006',"
-                            + " c4 Int DEFAULT -1)",
-                            typeName);
-                string createProcSql = string.Format(
-                        "CREATE PROC {0}(@tvp {1} READONLY) AS SELECT TOP(2) * FROM @tvp ORDER BY c1", procName, typeName);
-                string dropSql = string.Format("DROP PROC {0}; DROP TYPE {1}", procName, typeName);
+            using SqlConnection conn = new(_connStr);
+            conn.Open();
+
+            Guid randomizer = Guid.NewGuid();
+            string typeName = string.Format("dbo.[QHint_{0}]", randomizer);
+            string procName = string.Format("dbo.[QHint_Proc_{0}]", randomizer);
+            string createTypeSql = string.Format(
+                    "CREATE TYPE {0} AS TABLE("
+                        + " c1 Int DEFAULT -1,"
+                        + " c2 NVarChar(40) DEFAULT N'DEFUALT',"
+                        + " c3 DateTime DEFAULT '1/1/2006',"
+                        + " c4 Int DEFAULT -1)",
+                        typeName);
+            string createProcSql = string.Format(
+                    "CREATE PROC {0}(@tvp {1} READONLY) AS SELECT TOP(2) * FROM @tvp ORDER BY c1", procName, typeName);
+            string dropSql = string.Format("DROP PROC {0}; DROP TYPE {1}", procName, typeName);
 
-                try
-                {
-                    SqlCommand cmd = new SqlCommand(createTypeSql, conn);
-                    cmd.ExecuteNonQuery();
+            try
+            {
+                SqlCommand cmd = new(createTypeSql, conn);
+                cmd.ExecuteNonQuery();
 
-                    cmd.CommandText = createProcSql;
-                    cmd.ExecuteNonQuery();
+                cmd.CommandText = createProcSql;
+                cmd.ExecuteNonQuery();
 
-                    cmd.CommandText = procName;
-                    cmd.CommandType = CommandType.StoredProcedure;
-                    SqlParameter param = cmd.Parameters.Add("@tvp", SqlDbType.Structured);
+                cmd.CommandText = procName;
+                cmd.CommandType = CommandType.StoredProcedure;
+                SqlParameter param = cmd.Parameters.Add("@tvp", SqlDbType.Structured);
 
-                    SqlMetaData[] columnMetadata;
-                    List<SqlDataRecord> rows = new List<SqlDataRecord>();
-                    SqlDataRecord record;
+                SqlMetaData[] columnMetadata;
+                List<SqlDataRecord> rows = new();
+                SqlDataRecord record;
 
-                    Console.WriteLine("------- Sort order + uniqueness #1: simple -------");
-                    columnMetadata = new SqlMetaData[] {
+                Console.WriteLine("------- Sort order + uniqueness #1: simple -------");
+                columnMetadata = new SqlMetaData[] {
                             new SqlMetaData("", SqlDbType.Int, false, true, SortOrder.Ascending, 0),
                             new SqlMetaData("", SqlDbType.NVarChar, 40, false, true, SortOrder.Descending, 1),
                             new SqlMetaData("", SqlDbType.DateTime, false, true, SortOrder.Ascending, 2),
                             new SqlMetaData("", SqlDbType.Int, false, true, SortOrder.Descending, 3),
                         };
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(0, "Z-value", DateTime.Parse("03/01/2000"), 5);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(0, "Z-value", DateTime.Parse("03/01/2000"), 5);
+                rows.Add(record);
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(1, "Y-value", DateTime.Parse("02/01/2000"), 6);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(1, "Y-value", DateTime.Parse("02/01/2000"), 6);
+                rows.Add(record);
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(1, "X-value", DateTime.Parse("01/01/2000"), 7);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(1, "X-value", DateTime.Parse("01/01/2000"), 7);
+                rows.Add(record);
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(1, "X-value", DateTime.Parse("04/01/2000"), 8);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(1, "X-value", DateTime.Parse("04/01/2000"), 8);
+                rows.Add(record);
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(1, "X-value", DateTime.Parse("04/01/2000"), 4);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(1, "X-value", DateTime.Parse("04/01/2000"), 4);
+                rows.Add(record);
 
-                    param.Value = rows;
-                    using (SqlDataReader rdr = cmd.ExecuteReader())
-                    {
-                        WriteReader(rdr);
-                    }
-                    rows.Clear();
+                param.Value = rows;
+                using (SqlDataReader rdr = cmd.ExecuteReader())
+                {
+                    WriteReader(rdr);
+                }
+                rows.Clear();
 
-                    Console.WriteLine("------- Sort order + uniqueness #2: mixed order -------");
-                    columnMetadata = new SqlMetaData[] {
+                Console.WriteLine("------- Sort order + uniqueness #2: mixed order -------");
+                columnMetadata = new SqlMetaData[] {
                             new SqlMetaData("", SqlDbType.Int, false, true, SortOrder.Descending, 3),
                             new SqlMetaData("", SqlDbType.NVarChar, 40, false, true, SortOrder.Descending, 0),
                             new SqlMetaData("", SqlDbType.DateTime, false, true, SortOrder.Ascending, 2),
                             new SqlMetaData("", SqlDbType.Int, false, true, SortOrder.Ascending, 1),
                         };
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(6, "Z-value", DateTime.Parse("01/01/2000"), 1);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(6, "Z-value", DateTime.Parse("01/01/2000"), 1);
+                rows.Add(record);
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(6, "Z-value", DateTime.Parse("01/01/2000"), 2);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(6, "Z-value", DateTime.Parse("01/01/2000"), 2);
+                rows.Add(record);
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(6, "Y-value", DateTime.Parse("01/01/2000"), 3);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(6, "Y-value", DateTime.Parse("01/01/2000"), 3);
+                rows.Add(record);
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(6, "Y-value", DateTime.Parse("02/01/2000"), 3);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(6, "Y-value", DateTime.Parse("02/01/2000"), 3);
+                rows.Add(record);
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(5, "X-value", DateTime.Parse("03/01/2000"), 3);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(5, "X-value", DateTime.Parse("03/01/2000"), 3);
+                rows.Add(record);
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(4, "X-value", DateTime.Parse("01/01/2000"), 3);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(4, "X-value", DateTime.Parse("01/01/2000"), 3);
+                rows.Add(record);
 
-                    param.Value = rows;
-                    using (SqlDataReader rdr = cmd.ExecuteReader())
-                    {
-                        WriteReader(rdr);
-                    }
-                    rows.Clear();
+                param.Value = rows;
+                using (SqlDataReader rdr = cmd.ExecuteReader())
+                {
+                    WriteReader(rdr);
+                }
+                rows.Clear();
 
-                    Console.WriteLine("------- default column #1: outer subset -------");
-                    columnMetadata = new SqlMetaData[] {
+                Console.WriteLine("------- default column #1: outer subset -------");
+                columnMetadata = new SqlMetaData[] {
                             new SqlMetaData("", SqlDbType.Int, true, false, SortOrder.Unspecified, -1),
                             new SqlMetaData("", SqlDbType.NVarChar, 40, false, false, SortOrder.Unspecified, -1),
                             new SqlMetaData("", SqlDbType.DateTime, false, false, SortOrder.Unspecified, -1),
                             new SqlMetaData("", SqlDbType.Int, true, false, SortOrder.Unspecified, -1),
                         };
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(6, "Z-value", DateTime.Parse("01/01/2000"), 1);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(6, "Z-value", DateTime.Parse("01/01/2000"), 1);
+                rows.Add(record);
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(6, "Z-value", DateTime.Parse("01/01/2000"), 2);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(6, "Z-value", DateTime.Parse("01/01/2000"), 2);
+                rows.Add(record);
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(6, "Y-value", DateTime.Parse("01/01/2000"), 3);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(6, "Y-value", DateTime.Parse("01/01/2000"), 3);
+                rows.Add(record);
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(6, "Y-value", DateTime.Parse("02/01/2000"), 3);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(6, "Y-value", DateTime.Parse("02/01/2000"), 3);
+                rows.Add(record);
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(5, "X-value", DateTime.Parse("03/01/2000"), 3);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(5, "X-value", DateTime.Parse("03/01/2000"), 3);
+                rows.Add(record);
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(4, "X-value", DateTime.Parse("01/01/2000"), 3);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(4, "X-value", DateTime.Parse("01/01/2000"), 3);
+                rows.Add(record);
 
-                    param.Value = rows;
-                    using (SqlDataReader rdr = cmd.ExecuteReader())
-                    {
-                        WriteReader(rdr);
-                    }
-                    rows.Clear();
+                param.Value = rows;
+                using (SqlDataReader rdr = cmd.ExecuteReader())
+                {
+                    WriteReader(rdr);
+                }
+                rows.Clear();
 
-                    Console.WriteLine("------- default column #1: middle subset -------");
-                    columnMetadata = new SqlMetaData[] {
+                Console.WriteLine("------- default column #1: middle subset -------");
+                columnMetadata = new SqlMetaData[] {
                             new SqlMetaData("", SqlDbType.Int, false, false, SortOrder.Unspecified, -1),
                             new SqlMetaData("", SqlDbType.NVarChar, 40, true, false, SortOrder.Unspecified, -1),
                             new SqlMetaData("", SqlDbType.DateTime, true, false, SortOrder.Unspecified, -1),
                             new SqlMetaData("", SqlDbType.Int, false, false, SortOrder.Unspecified, -1),
                         };
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(6, "Z-value", DateTime.Parse("01/01/2000"), 1);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(6, "Z-value", DateTime.Parse("01/01/2000"), 1);
+                rows.Add(record);
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(6, "Z-value", DateTime.Parse("01/01/2000"), 2);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(6, "Z-value", DateTime.Parse("01/01/2000"), 2);
+                rows.Add(record);
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(6, "Y-value", DateTime.Parse("01/01/2000"), 3);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(6, "Y-value", DateTime.Parse("01/01/2000"), 3);
+                rows.Add(record);
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(6, "Y-value", DateTime.Parse("02/01/2000"), 3);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(6, "Y-value", DateTime.Parse("02/01/2000"), 3);
+                rows.Add(record);
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(5, "X-value", DateTime.Parse("03/01/2000"), 3);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(5, "X-value", DateTime.Parse("03/01/2000"), 3);
+                rows.Add(record);
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(4, "X-value", DateTime.Parse("01/01/2000"), 3);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(4, "X-value", DateTime.Parse("01/01/2000"), 3);
+                rows.Add(record);
 
-                    param.Value = rows;
-                    using (SqlDataReader rdr = cmd.ExecuteReader())
-                    {
-                        WriteReader(rdr);
-                    }
-                    rows.Clear();
+                param.Value = rows;
+                using (SqlDataReader rdr = cmd.ExecuteReader())
+                {
+                    WriteReader(rdr);
+                }
+                rows.Clear();
 
-                    Console.WriteLine("------- default column #1: all -------");
-                    columnMetadata = new SqlMetaData[] {
+                Console.WriteLine("------- default column #1: all -------");
+                columnMetadata = new SqlMetaData[] {
                             new SqlMetaData("", SqlDbType.Int, true, false, SortOrder.Unspecified, -1),
                             new SqlMetaData("", SqlDbType.NVarChar, 40, true, false, SortOrder.Unspecified, -1),
                             new SqlMetaData("", SqlDbType.DateTime, true, false, SortOrder.Unspecified, -1),
                             new SqlMetaData("", SqlDbType.Int, true, false, SortOrder.Unspecified, -1),
                         };
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(6, "Z-value", DateTime.Parse("01/01/2000"), 1);
-                    rows.Add(record);
-
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(6, "Z-value", DateTime.Parse("01/01/2000"), 2);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(6, "Z-value", DateTime.Parse("01/01/2000"), 1);
+                rows.Add(record);
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(6, "Y-value", DateTime.Parse("01/01/2000"), 3);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(6, "Z-value", DateTime.Parse("01/01/2000"), 2);
+                rows.Add(record);
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(6, "Y-value", DateTime.Parse("02/01/2000"), 3);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(6, "Y-value", DateTime.Parse("01/01/2000"), 3);
+                rows.Add(record);
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(5, "X-value", DateTime.Parse("03/01/2000"), 3);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(6, "Y-value", DateTime.Parse("02/01/2000"), 3);
+                rows.Add(record);
 
-                    record = new SqlDataRecord(columnMetadata);
-                    record.SetValues(4, "X-value", DateTime.Parse("01/01/2000"), 3);
-                    rows.Add(record);
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(5, "X-value", DateTime.Parse("03/01/2000"), 3);
+                rows.Add(record);
 
-                    param.Value = rows;
-                    using (SqlDataReader rdr = cmd.ExecuteReader())
-                    {
-                        WriteReader(rdr);
-                    }
-                    rows.Clear();
+                record = new SqlDataRecord(columnMetadata);
+                record.SetValues(4, "X-value", DateTime.Parse("01/01/2000"), 3);
+                rows.Add(record);
 
-                }
-                catch (Exception e)
+                param.Value = rows;
+                using (SqlDataReader rdr = cmd.ExecuteReader())
                 {
-                    Console.WriteLine(e.Message);
-                }
-                finally
-                {
-                    SqlCommand cmd = new SqlCommand(dropSql, conn);
-                    cmd.ExecuteNonQuery();
+                    WriteReader(rdr);
                 }
+                rows.Clear();
 
             }
+            catch (Exception e)
+            {
+                Console.WriteLine(e.Message);
+            }
+            finally
+            {
+                SqlCommand cmd = new(dropSql, conn);
+                cmd.ExecuteNonQuery();
+            }
         }
 
         private static async Task RunPacketNumberWraparound(WraparoundRowEnumerator enumerator)
         {
-            using (var connection = new SqlConnection(DataTestUtility.TCPConnectionString))
-            using (var cmd = new SqlCommand("unimportant")
+            using var connection = new SqlConnection(DataTestUtility.TCPConnectionString);
+            using var cmd = new SqlCommand("unimportant")
             {
-                CommandType = System.Data.CommandType.StoredProcedure,
+                CommandType = CommandType.StoredProcedure,
                 Connection = connection,
-            })
+            };
+            await cmd.Connection.OpenAsync();
+            cmd.Parameters.Add(new SqlParameter("@rows", SqlDbType.Structured)
             {
-                await cmd.Connection.OpenAsync();
-                cmd.Parameters.Add(new SqlParameter("@rows", SqlDbType.Structured)
-                {
-                    TypeName = "unimportant",
-                    Value = enumerator,
-                });
-                try
-                {
-                    await cmd.ExecuteNonQueryAsync();
-                }
-                catch (Exception)
-                {
-                    // ignore the errors caused by the sproc and table type not existing
-                }
+                TypeName = "unimportant",
+                Value = enumerator,
+            });
+            try
+            {
+                await cmd.ExecuteNonQueryAsync();
+            }
+            catch (Exception)
+            {
+                // ignore the errors caused by the sproc and table type not existing
             }
         }
 
@@ -709,7 +703,6 @@ private static async Task RunPacketNumberWraparound(WraparoundRowEnumerator enum
 
         private bool AllowableDifference(string source, object result, StePermutation metadata)
         {
-            object value;
             bool returnValue = false;
 
             // turn result into a string
@@ -733,7 +726,7 @@ private bool AllowableDifference(string source, object result, StePermutation me
                 {
                     returnValue = true;
                 }
-                else if (metadata.TryGetValue(SteAttributeKey.MaxLength, out value) && value != SteTypeBoundaries.s_doNotUseMarker)
+                else if (metadata.TryGetValue(SteAttributeKey.MaxLength, out object value) && value != SteTypeBoundaries.s_doNotUseMarker)
                 {
                     int maxLength = (int)value;
 
@@ -760,7 +753,6 @@ private bool AllowableDifference(string source, object result, StePermutation me
 
         private bool AllowableDifference(byte[] source, object result, StePermutation metadata)
         {
-            object value;
             bool returnValue = false;
 
             // turn result into byte array
@@ -780,7 +772,7 @@ private bool AllowableDifference(byte[] source, object result, StePermutation me
                 {
                     returnValue = true;
                 }
-                else if (metadata.TryGetValue(SteAttributeKey.MaxLength, out value) && value != SteTypeBoundaries.s_doNotUseMarker)
+                else if (metadata.TryGetValue(SteAttributeKey.MaxLength, out object value) && value != SteTypeBoundaries.s_doNotUseMarker)
                 {
                     int maxLength = (int)value;
 
@@ -807,8 +799,6 @@ private bool AllowableDifference(byte[] source, object result, StePermutation me
 
         private bool AllowableDifference(SqlDecimal source, object result, StePermutation metadata)
         {
-            object value;
-            object value2;
             bool returnValue = false;
 
             // turn result into SqlDecimal
@@ -832,7 +822,7 @@ private bool AllowableDifference(SqlDecimal source, object result, StePermutatio
                 {
                     returnValue = true;
                 }
-                else if (metadata.TryGetValue(SteAttributeKey.SqlDbType, out value) &&
+                else if (metadata.TryGetValue(SteAttributeKey.SqlDbType, out object value) &&
                         SteTypeBoundaries.s_doNotUseMarker != value &&
                         (SqlDbType.SmallMoney == (SqlDbType)value ||
                          SqlDbType.Money == (SqlDbType)value))
@@ -856,7 +846,7 @@ private bool AllowableDifference(SqlDecimal source, object result, StePermutatio
                         SqlDbType.Decimal == (SqlDbType)value)
                 {
                     if (metadata.TryGetValue(SteAttributeKey.Scale, out value) &&
-                            metadata.TryGetValue(SteAttributeKey.Precision, out value2) &&
+                            metadata.TryGetValue(SteAttributeKey.Precision, out object value2) &&
                             SteTypeBoundaries.s_doNotUseMarker != value &&
                             SteTypeBoundaries.s_doNotUseMarker != value2)
                     {
@@ -905,55 +895,55 @@ private bool CompareValue(object result, object source, StePermutation metadata)
                                 break;
                             case TypeCode.Object:
                                 {
-                                    if (source is char[])
+                                    if (source is char[] charSource)
                                     {
-                                        source = new string((char[])source);
+                                        source = new string(charSource);
                                         isMatch = AllowableDifference((string)source, result, metadata);
                                     }
-                                    else if (source is byte[])
+                                    else if (source is byte[] byteSource)
                                     {
-                                        isMatch = AllowableDifference((byte[])source, result, metadata);
+                                        isMatch = AllowableDifference(byteSource, result, metadata);
                                     }
-                                    else if (source is SqlBytes)
+                                    else if (source is SqlBytes sqlBytesSource)
                                     {
-                                        isMatch = AllowableDifference(((SqlBytes)source).Value, result, metadata);
+                                        isMatch = AllowableDifference(sqlBytesSource.Value, result, metadata);
                                     }
-                                    else if (source is SqlChars)
+                                    else if (source is SqlChars sqlCharSource)
                                     {
-                                        source = new string(((SqlChars)source).Value);
+                                        source = new string(sqlCharSource.Value);
                                         isMatch = AllowableDifference((string)source, result, metadata);
                                     }
-                                    else if (source is SqlInt64 && result is long)
+                                    else if (source is SqlInt64 @int && result is long)
                                     {
-                                        isMatch = result.Equals(((SqlInt64)source).Value);
+                                        isMatch = result.Equals(@int.Value);
                                     }
-                                    else if (source is SqlInt32 && result is int)
+                                    else if (source is SqlInt32 shortSource && result is int)
                                     {
-                                        isMatch = result.Equals(((SqlInt32)source).Value);
+                                        isMatch = result.Equals(shortSource.Value);
                                     }
-                                    else if (source is SqlInt16 && result is short)
+                                    else if (source is SqlInt16 intSource && result is short)
                                     {
-                                        isMatch = result.Equals(((SqlInt16)source).Value);
+                                        isMatch = result.Equals(intSource.Value);
                                     }
-                                    else if (source is SqlSingle && result is float)
+                                    else if (source is SqlSingle singleSource && result is float)
                                     {
-                                        isMatch = result.Equals(((SqlSingle)source).Value);
+                                        isMatch = result.Equals(singleSource.Value);
                                     }
-                                    else if (source is SqlDouble && result is double)
+                                    else if (source is SqlDouble @double && result is double)
                                     {
-                                        isMatch = result.Equals(((SqlDouble)source).Value);
+                                        isMatch = result.Equals(@double.Value);
                                     }
-                                    else if (source is SqlDateTime && result is DateTime)
+                                    else if (source is SqlDateTime timeSource && result is DateTime)
                                     {
-                                        isMatch = result.Equals(((SqlDateTime)source).Value);
+                                        isMatch = result.Equals(timeSource.Value);
                                     }
-                                    else if (source is SqlMoney)
+                                    else if (source is SqlMoney sqlMoneySource)
                                     {
-                                        isMatch = AllowableDifference(new SqlDecimal(((SqlMoney)source).Value), result, metadata);
+                                        isMatch = AllowableDifference(new SqlDecimal(sqlMoneySource.Value), result, metadata);
                                     }
-                                    else if (source is SqlDecimal)
+                                    else if (source is SqlDecimal @decimal)
                                     {
-                                        isMatch = AllowableDifference((SqlDecimal)source, result, metadata);
+                                        isMatch = AllowableDifference(@decimal, result, metadata);
                                     }
                                 }
                                 break;
@@ -995,11 +985,11 @@ private IList<SqlDataRecord> CreateListOfRecords(StePermutation tvpPerm, object[
                 i++;
             }
 
-            List<SqlDataRecord> records = new List<SqlDataRecord>(baseValues.Length);
+            List<SqlDataRecord> records = new(baseValues.Length);
             for (int rowOrd = 0; rowOrd < baseValues.Length; rowOrd++)
             {
                 object[] row = baseValues[rowOrd];
-                SqlDataRecord rec = new SqlDataRecord(fieldMetadata);
+                SqlDataRecord rec = new(fieldMetadata);
                 records.Add(rec); // Call SetValue *after* Add to ensure record is put in list
                 for (int colOrd = 0; colOrd < row.Length; colOrd++)
                 {
@@ -1024,7 +1014,7 @@ private IList<SqlDataRecord> CreateListOfRecords(StePermutation tvpPerm, object[
 
         private DataTable CreateNewTable(object[] row, ref Type[] lastRowTypes)
         {
-            DataTable dt = new DataTable();
+            DataTable dt = new();
             for (int i = 0; i < row.Length; i++)
             {
                 object value = row[i];
@@ -1057,7 +1047,7 @@ private void CreateServerObjects(StePermutation tvpPerm)
         {
 
             // Create the table type tsql
-            StringBuilder tsql = new StringBuilder();
+            StringBuilder tsql = new();
             tsql.Append("CREATE TYPE ");
             tsql.Append(GetTypeName(tvpPerm));
             tsql.Append(" AS TABLE(");
@@ -1197,19 +1187,17 @@ private void CreateServerObjects(StePermutation tvpPerm)
 
             tsql.Append(")");
 
-            using (SqlConnection conn = new SqlConnection(_connStr))
-            {
-                conn.Open();
+            using SqlConnection conn = new(_connStr);
+            conn.Open();
 
-                // execute it to create the type
-                SqlCommand cmd = new SqlCommand(tsql.ToString(), conn);
-                cmd.ExecuteNonQuery();
+            // execute it to create the type
+            SqlCommand cmd = new(tsql.ToString(), conn);
+            cmd.ExecuteNonQuery();
 
-                // and create the proc that uses the type            
-                cmd.CommandText = string.Format("CREATE PROC {0}(@tvp {1} READONLY) AS SELECT * FROM @tvp order by {2}",
-                        GetProcName(tvpPerm), GetTypeName(tvpPerm), colOrdinal - 1);
-                cmd.ExecuteNonQuery();
-            }
+            // and create the proc that uses the type            
+            cmd.CommandText = string.Format("CREATE PROC {0}(@tvp {1} READONLY) AS SELECT * FROM @tvp order by {2}",
+                    GetProcName(tvpPerm), GetTypeName(tvpPerm), colOrdinal - 1);
+            cmd.ExecuteNonQuery();
         }
 
         private bool DoesRowMatchMetadata(object[] row, DataTable table)
@@ -1235,62 +1223,54 @@ private bool DoesRowMatchMetadata(object[] row, DataTable table)
         private void DropServerObjects(StePermutation tvpPerm)
         {
             string dropText = "DROP PROC " + GetProcName(tvpPerm) + "; DROP TYPE " + GetTypeName(tvpPerm);
-            using (SqlConnection conn = new SqlConnection(_connStr))
-            {
-                conn.Open();
+            using SqlConnection conn = new(_connStr);
+            conn.Open();
 
-                SqlCommand cmd = new SqlCommand(dropText, conn);
-                try
-                {
-                    cmd.ExecuteNonQuery();
-                }
-                catch (SqlException e)
-                {
-                    Console.WriteLine("SqlException dropping objects: {0}", e.Number);
-                }
+            SqlCommand cmd = new(dropText, conn);
+            try
+            {
+                cmd.ExecuteNonQuery();
+            }
+            catch (SqlException e)
+            {
+                Console.WriteLine("SqlException dropping objects: {0}", e.Number);
             }
         }
 
         private void ExecuteAndVerify(SqlCommand cmd, StePermutation tvpPerm, object[][] objValues, DataTable dtValues)
         {
-            using (SqlConnection conn = new SqlConnection(_connStr))
+            using SqlConnection conn = new(_connStr);
+            conn.Open();
+            cmd.Connection = conn;
+            if (DataTestUtility.IsNotAzureServer())
             {
-                conn.Open();
-                cmd.Connection = conn;
-                if (DataTestUtility.IsNotAzureServer())
-                {
-                    // Choose the 2628 error message instead of 8152 in SQL Server 2016 & 2017
-                    using (SqlCommand cmdFix = new SqlCommand("DBCC TRACEON(460)", conn))
-                    {
-                        cmdFix.ExecuteNonQuery();
-                    }
-                }
+                // Choose the 2628 error message instead of 8152 in SQL Server 2016 & 2017
+                using SqlCommand cmdFix = new("DBCC TRACEON(460)", conn);
+                cmdFix.ExecuteNonQuery();
+            }
 
-                try
-                {
-                    using (SqlDataReader rdr = cmd.ExecuteReader())
-                    {
-                        VerifyColumnBoundaries(rdr, GetFields(tvpPerm), objValues, dtValues);
-                    }
-                }
-                catch (SqlException se)
-                {
-                    Console.WriteLine("SqlException. Error Code: {0}", se.Number);
-                }
-                catch (InvalidOperationException ioe)
-                {
-                    Console.WriteLine("InvalidOp: {0}", ioe.Message);
-                }
-                catch (ArgumentException ae)
-                {
-                    Console.WriteLine("ArgumentException: {0}", ae.Message);
-                }
+            try
+            {
+                using SqlDataReader rdr = cmd.ExecuteReader();
+                VerifyColumnBoundaries(rdr, GetFields(tvpPerm), objValues, dtValues);
+            }
+            catch (SqlException se)
+            {
+                Console.WriteLine("SqlException. Error Code: {0}", se.Number);
+            }
+            catch (InvalidOperationException ioe)
+            {
+                Console.WriteLine("InvalidOp: {0}", ioe.Message);
+            }
+            catch (ArgumentException ae)
+            {
+                Console.WriteLine("ArgumentException: {0}", ae.Message);
             }
         }
 
         private IList<DataTable> GenerateDataTables(object[][] values)
         {
-            List<DataTable> dtList = new List<DataTable>();
+            List<DataTable> dtList = new();
             Type[] valueTypes = new Type[values[0].Length];
             foreach (object[] row in values)
             {
@@ -1352,22 +1332,21 @@ private bool IsNull(object value)
         {
             return null == value ||
                     DBNull.Value == value ||
-                    (value is INullable &&
-                     ((INullable)value).IsNull);
+                    (value is INullable nullable &&
+                     nullable.IsNull);
         }
 
         private SqlMetaData PermToSqlMetaData(StePermutation perm)
         {
-            object attr;
             SqlDbType sqlDbType;
             int maxLength = 0;
             byte precision = 0;
             byte scale = 0;
-            string typeName = null;
+            string typeName;
             Type type = null;
             long localeId = 0;
             SqlCompareOptions opts = SqlCompareOptions.IgnoreCase | SqlCompareOptions.IgnoreKanaType | SqlCompareOptions.IgnoreWidth;
-            if (perm.TryGetValue(SteAttributeKey.SqlDbType, out attr) && (attr != SteTypeBoundaries.s_doNotUseMarker))
+            if (perm.TryGetValue(SteAttributeKey.SqlDbType, out object attr) && (attr != SteTypeBoundaries.s_doNotUseMarker))
             {
                 sqlDbType = (SqlDbType)attr;
             }
@@ -1528,7 +1507,7 @@ private void DumpSqlParam(SqlParameter param)
 
     internal class TvpRestartableReader : DbDataReader
     {
-        private IList<SqlDataRecord> _sourceData;
+        private readonly IList<SqlDataRecord> _sourceData;
         int _currentRow;
 
         internal TvpRestartableReader(IList<SqlDataRecord> source) : base()
@@ -1611,7 +1590,7 @@ override public DataTable GetSchemaTable()
         {
             SqlDataRecord rec = _sourceData[0];
 
-            DataTable schemaTable = new DataTable();
+            DataTable schemaTable = new();
             schemaTable.Columns.Add(new DataColumn(SchemaTableColumn.ColumnName, typeof(string)));
             schemaTable.Columns.Add(new DataColumn(SchemaTableColumn.ColumnOrdinal, typeof(int)));
             schemaTable.Columns.Add(new DataColumn(SchemaTableColumn.ColumnSize, typeof(int)));
@@ -1782,7 +1761,7 @@ internal class WraparoundRowEnumerator : IEnumerable<SqlDataRecord>, IEnumerator
     {
         private int _count;
         private int _maxCount;
-        private SqlDataRecord _record;
+        private readonly SqlDataRecord _record;
 
         public WraparoundRowEnumerator(int maxCount)
         {
@@ -1811,8 +1790,8 @@ public bool MoveNext()
 
         object IEnumerator.Current => Current;
 
-        public int Count { get => this._count; set => this._count = value; }
-        public int MaxCount { get => this._maxCount; set => this._maxCount = value; }
+        public int Count { get => _count; set => _count = value; }
+        public int MaxCount { get => _maxCount; set => _maxCount = value; }
 
         public IEnumerator<SqlDataRecord> GetEnumerator() => this;