.github/FUNDING.yml

+# These are supported funding model platforms
+
+github: [mgravell, dapperlib]
+custom: ["https://www.buymeacoffee.com/marcgravell"]

Dapper.EntityFramework.StrongName/Dapper.EntityFramework.StrongName.csproj

@@ -10,14 +10,14 @@
     <PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
     <PackageId>Dapper.EntityFramework.StrongName</PackageId>
     <PackageTags>orm;sql;micro-orm</PackageTags>
+    <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="..\Dapper.EntityFramework\**\*.cs" Exclude="..\Dapper.EntityFramework\obj\**\*.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Dapper.StrongName\Dapper.StrongName.csproj" />
-    <!-- note: 6.2.0 has regressions; don't force the update -->
-    <PackageReference Include="EntityFramework" Version="6.1.3" />
-    <PackageReference Include="Microsoft.SqlServer.Types" Version="14.0.1016.290" />
+    <PackageReference Include="EntityFramework" />
+    <PackageReference Include="Microsoft.SqlServer.Types" />
   </ItemGroup>
 </Project>

Dapper.EntityFramework/Dapper.EntityFramework.csproj

@@ -7,11 +7,16 @@
     <Authors>Marc Gravell;Nick Craver</Authors>
     <TargetFrameworks>net461</TargetFrameworks>
     <PackageTags>orm;sql;micro-orm</PackageTags>
+    <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
     <ProjectReference Include="..\Dapper\Dapper.csproj" />
-    <!-- note: 6.2.0 has regressions; don't force the update -->
-    <PackageReference Include="EntityFramework" Version="6.1.3" />
-    <PackageReference Include="Microsoft.SqlServer.Types" Version="14.0.1016.290" />
+    <PackageReference Include="EntityFramework" />
+    <PackageReference Include="Microsoft.SqlServer.Types" />
+
+    <PackageReference Include="Microsoft.CodeAnalysis.PublicApiAnalyzers">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
   </ItemGroup>
 </Project>
\ No newline at end of file

Dapper.EntityFramework/DbGeographyHandler.cs

@@ -27,10 +27,10 @@ public class DbGeographyHandler : SqlMapper.TypeHandler<DbGeography>
         /// </summary>
         /// <param name="parameter">The parameter to configure.</param>
         /// <param name="value">Parameter value.</param>
-        public override void SetValue(IDbDataParameter parameter, DbGeography value)
+        public override void SetValue(IDbDataParameter parameter, DbGeography? value)
         {
-            object parsed = null;
-            if (value != null)
+            object? parsed = null;
+            if (value is not null)
             {
                 parsed = SqlGeography.STGeomFromWKB(new SqlBytes(value.AsBinary()), value.CoordinateSystemId);
             }
@@ -46,9 +46,9 @@ public override void SetValue(IDbDataParameter parameter, DbGeography value)
         /// </summary>
         /// <param name="value">The value from the database.</param>
         /// <returns>The typed value.</returns>
-        public override DbGeography Parse(object value)
+        public override DbGeography? Parse(object? value)
         {
-            if (value == null || value is DBNull) return null;
+            if (value is null || value is DBNull) return null;
             if (value is SqlGeography geo)
             {
                 return DbGeography.FromBinary(geo.STAsBinary().Value, geo.STSrid.Value);

Dapper.EntityFramework/DbGeometryHandler.cs

@@ -27,10 +27,10 @@ public class DbGeometryHandler : SqlMapper.TypeHandler<DbGeometry>
         /// </summary>
         /// <param name="parameter">The parameter to configure.</param>
         /// <param name="value">Parameter value.</param>
-        public override void SetValue(IDbDataParameter parameter, DbGeometry value)
+        public override void SetValue(IDbDataParameter parameter, DbGeometry? value)
         {
-            object parsed = null;
-            if (value != null)
+            object? parsed = null;
+            if (value is not null)
             {
                 parsed = SqlGeometry.STGeomFromWKB(new SqlBytes(value.AsBinary()), value.CoordinateSystemId);
             }
@@ -46,9 +46,9 @@ public override void SetValue(IDbDataParameter parameter, DbGeometry value)
         /// </summary>
         /// <param name="value">The value from the database.</param>
         /// <returns>The typed value.</returns>
-        public override DbGeometry Parse(object value)
+        public override DbGeometry? Parse(object? value)
         {
-            if (value == null || value is DBNull) return null;
+            if (value is null || value is DBNull) return null;
             if (value is SqlGeometry geo)
             {
                 return DbGeometry.FromBinary(geo.STAsBinary().Value, geo.STSrid.Value);

Dapper.EntityFramework/PublicAPI.Shipped.txt

+#nullable enable
+Dapper.EntityFramework.DbGeographyHandler
+Dapper.EntityFramework.DbGeographyHandler.DbGeographyHandler() -> void
+Dapper.EntityFramework.DbGeometryHandler
+Dapper.EntityFramework.DbGeometryHandler.DbGeometryHandler() -> void
+Dapper.EntityFramework.Handlers
+override Dapper.EntityFramework.DbGeographyHandler.Parse(object? value) -> System.Data.Entity.Spatial.DbGeography?
+override Dapper.EntityFramework.DbGeographyHandler.SetValue(System.Data.IDbDataParameter! parameter, System.Data.Entity.Spatial.DbGeography? value) -> void
+override Dapper.EntityFramework.DbGeometryHandler.Parse(object? value) -> System.Data.Entity.Spatial.DbGeometry?
+override Dapper.EntityFramework.DbGeometryHandler.SetValue(System.Data.IDbDataParameter! parameter, System.Data.Entity.Spatial.DbGeometry? value) -> void
+static Dapper.EntityFramework.Handlers.Register() -> void
+static readonly Dapper.EntityFramework.DbGeographyHandler.Default -> Dapper.EntityFramework.DbGeographyHandler!
+static readonly Dapper.EntityFramework.DbGeometryHandler.Default -> Dapper.EntityFramework.DbGeometryHandler!
\ No newline at end of file

Dapper.EntityFramework/PublicAPI.Unshipped.txt

+#nullable enable
\ No newline at end of file

Dapper.ProviderTools/BulkCopy.cs

@@ -20,7 +20,7 @@ public abstract class BulkCopy : IDisposable
         /// </summary>
         public static BulkCopy? TryCreate(DbConnection connection)
         {
-            if (connection == null) return null;
+            if (connection is null) return null;
             var type = connection.GetType();
             if (!s_bcpFactory.TryGetValue(type, out var func))
             {
@@ -36,9 +36,9 @@ public abstract class BulkCopy : IDisposable
         public static BulkCopy Create(DbConnection connection)
         {
             var bcp = TryCreate(connection);
-            if (bcp == null)
+            if (bcp is null)
             {
-                if (connection == null) throw new ArgumentNullException(nameof(connection));
+                if (connection is null) throw new ArgumentNullException(nameof(connection));
                 throw new NotSupportedException("Unable to create BulkCopy for " + connection.GetType().FullName);
             }
             return bcp;
@@ -64,10 +64,10 @@ public static BulkCopy Create(DbConnection connection)
                 {
                     var prefix = match.Groups[1].Value;
                     var bcpType = connectionType.Assembly.GetType($"{connectionType.Namespace}.{prefix}BulkCopy");
-                    if (bcpType != null)
+                    if (bcpType is not null)
                     {
                         var ctor = bcpType.GetConstructor(new[] { connectionType });
-                        if (ctor == null) return null;
+                        if (ctor is null) return null;
 
                         var p = Expression.Parameter(typeof(DbConnection), "conn");
                         var body = Expression.New(ctor, Expression.Convert(p, connectionType));
@@ -98,14 +98,17 @@ public static BulkCopy Create(DbConnection connection)
         /// <summary>
         /// Write a set of data to the server
         /// </summary>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0026:Do not add multiple public overloads with optional parameters", Justification = "Grandfathered")]
         public abstract Task WriteToServerAsync(DbDataReader source, CancellationToken cancellationToken = default);
         /// <summary>
         /// Write a set of data to the server
         /// </summary>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0026:Do not add multiple public overloads with optional parameters", Justification = "Grandfathered")]
         public abstract Task WriteToServerAsync(DataTable source, CancellationToken cancellationToken = default);
         /// <summary>
         /// Write a set of data to the server
         /// </summary>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0026:Do not add multiple public overloads with optional parameters", Justification = "Grandfathered")]
         public abstract Task WriteToServerAsync(DataRow[] source, CancellationToken cancellationToken = default);
         /// <summary>
         /// Add a mapping between two columns by name

Dapper.ProviderTools/Dapper.ProviderTools.csproj

@@ -9,8 +9,14 @@
     <SignAssembly>true</SignAssembly>
     <Nullable>enable</Nullable>
   </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.PublicApiAnalyzers">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
   <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">
-    <PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
+    <PackageReference Include="Microsoft.CSharp" />
   </ItemGroup>
   <ItemGroup Condition=" '$(TargetFramework)' == 'net461' ">
     <Reference Include="Microsoft.CSharp" />

Dapper.ProviderTools/DbConnectionExtensions.cs

@@ -17,7 +17,7 @@ public static class DbConnectionExtensions
         public static bool TryGetClientConnectionId(this DbConnection connection, out Guid clientConnectionId)
         {
             clientConnectionId = default;
-            return connection != null && ByTypeHelpers.Get(connection.GetType()).TryGetClientConnectionId(
+            return connection is not null && ByTypeHelpers.Get(connection.GetType()).TryGetClientConnectionId(
                 connection, out clientConnectionId);
         }
 
@@ -25,13 +25,13 @@ public static bool TryGetClientConnectionId(this DbConnection connection, out Gu
         /// Clear all pools associated with the provided connection type
         /// </summary>
         public static bool TryClearAllPools(this DbConnection connection)
-            => connection != null && ByTypeHelpers.Get(connection.GetType()).TryClearAllPools();
+            => connection is not null && ByTypeHelpers.Get(connection.GetType()).TryClearAllPools();
 
         /// <summary>
         /// Clear the pools associated with the provided connection
         /// </summary>
         public static bool TryClearPool(this DbConnection connection)
-            => connection != null && ByTypeHelpers.Get(connection.GetType()).TryClearPool(connection);
+            => connection is not null && ByTypeHelpers.Get(connection.GetType()).TryClearPool(connection);
 
         private sealed class ByTypeHelpers
         {
@@ -44,7 +44,7 @@ private sealed class ByTypeHelpers
 
             public bool TryGetClientConnectionId(DbConnection connection, out Guid clientConnectionId)
             {
-                if (_getClientConnectionId == null)
+                if (_getClientConnectionId is null)
                 {
                     clientConnectionId = default;
                     return false;
@@ -55,14 +55,14 @@ public bool TryGetClientConnectionId(DbConnection connection, out Guid clientCon
 
             public bool TryClearPool(DbConnection connection)
             {
-                if (_clearPool == null) return false;
+                if (_clearPool is null) return false;
                 _clearPool(connection);
                 return true;
             }
 
             public bool TryClearAllPools()
             {
-                if (_clearAllPools == null) return false;
+                if (_clearAllPools is null) return false;
                 _clearAllPools();
                 return true;
             }
@@ -84,7 +84,7 @@ private ByTypeHelpers(Type type)
                 {
                     var clearAllPools = type.GetMethod("ClearAllPools", BindingFlags.Public | BindingFlags.Static,
                         null, Type.EmptyTypes, null);
-                    if (clearAllPools != null)
+                    if (clearAllPools is not null)
                     {
                         _clearAllPools = (Action)Delegate.CreateDelegate(typeof(Action), clearAllPools);
                     }
@@ -95,7 +95,7 @@ private ByTypeHelpers(Type type)
                 {
                     var clearPool = type.GetMethod("ClearPool", BindingFlags.Public | BindingFlags.Static,
                         null, new[] { type }, null);
-                    if (clearPool != null)
+                    if (clearPool is not null)
                     {
                         var p = Expression.Parameter(typeof(DbConnection), "connection");
                         var body = Expression.Call(clearPool, Expression.Convert(p, type));
@@ -111,7 +111,7 @@ private ByTypeHelpers(Type type)
                 try
                 {
                     var prop = type.GetProperty(name, BindingFlags.Public | BindingFlags.Instance);
-                    if (prop == null || !prop.CanRead) return null;
+                    if (prop is null || !prop.CanRead) return null;
                     if (prop.PropertyType != typeof(T)) return null;
 
                     var p = Expression.Parameter(typeof(DbConnection), "connection");

Dapper.ProviderTools/DbExceptionExtensions.cs

@@ -15,7 +15,7 @@ public static class DbExceptionExtensions
         /// Indicates whether the provided exception has an integer Number property with the supplied value
         /// </summary>
         public static bool IsNumber(this DbException exception, int number)
-            => exception != null && ByTypeHelpers.Get(exception.GetType()).IsNumber(exception, number);
+            => exception is not null && ByTypeHelpers.Get(exception.GetType()).IsNumber(exception, number);
 
 
         private sealed class ByTypeHelpers
@@ -25,7 +25,7 @@ private sealed class ByTypeHelpers
             private readonly Func<DbException, int>? _getNumber;
 
             public bool IsNumber(DbException exception, int number)
-                => _getNumber != null && _getNumber(exception) == number;
+                => _getNumber is not null && _getNumber(exception) == number;
 
             public static ByTypeHelpers Get(Type type)
             {
@@ -46,7 +46,7 @@ private ByTypeHelpers(Type type)
                 try
                 {
                     var prop = type.GetProperty(name, BindingFlags.Public | BindingFlags.Instance);
-                    if (prop == null || !prop.CanRead) return null;
+                    if (prop is null || !prop.CanRead) return null;
                     if (prop.PropertyType != typeof(T)) return null;
 
                     var p = Expression.Parameter(typeof(DbException), "exception");

Dapper.ProviderTools/Internal/DynamicBulkCopy.cs

@@ -9,7 +9,7 @@ namespace Dapper.ProviderTools.Internal
     internal sealed class DynamicBulkCopy : BulkCopy
     {
         internal static BulkCopy? Create(object? wrapped)
-            => wrapped == null ? null : new DynamicBulkCopy(wrapped);
+            => wrapped is null ? null : new DynamicBulkCopy(wrapped);
 
         private DynamicBulkCopy(object wrapped)
             => _wrapped = wrapped;

Dapper.ProviderTools/PublicAPI.Shipped.txt

+#nullable enable
+abstract Dapper.ProviderTools.BulkCopy.AddColumnMapping(int sourceColumn, int destinationColumn) -> void
+abstract Dapper.ProviderTools.BulkCopy.AddColumnMapping(string! sourceColumn, string! destinationColumn) -> void
+abstract Dapper.ProviderTools.BulkCopy.DestinationTableName.get -> string!
+abstract Dapper.ProviderTools.BulkCopy.DestinationTableName.set -> void
+abstract Dapper.ProviderTools.BulkCopy.Dispose(bool disposing) -> void
+abstract Dapper.ProviderTools.BulkCopy.Wrapped.get -> object!
+abstract Dapper.ProviderTools.BulkCopy.WriteToServer(System.Data.DataRow![]! source) -> void
+abstract Dapper.ProviderTools.BulkCopy.WriteToServer(System.Data.DataTable! source) -> void
+abstract Dapper.ProviderTools.BulkCopy.WriteToServer(System.Data.IDataReader! source) -> void
+abstract Dapper.ProviderTools.BulkCopy.WriteToServerAsync(System.Data.Common.DbDataReader! source, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!
+abstract Dapper.ProviderTools.BulkCopy.WriteToServerAsync(System.Data.DataRow![]! source, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!
+abstract Dapper.ProviderTools.BulkCopy.WriteToServerAsync(System.Data.DataTable! source, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!
+Dapper.ProviderTools.BulkCopy
+Dapper.ProviderTools.BulkCopy.BatchSize.get -> int
+Dapper.ProviderTools.BulkCopy.BatchSize.set -> void
+Dapper.ProviderTools.BulkCopy.BulkCopy() -> void
+Dapper.ProviderTools.BulkCopy.BulkCopyTimeout.get -> int
+Dapper.ProviderTools.BulkCopy.BulkCopyTimeout.set -> void
+Dapper.ProviderTools.BulkCopy.Dispose() -> void
+Dapper.ProviderTools.BulkCopy.EnableStreaming.get -> bool
+Dapper.ProviderTools.BulkCopy.EnableStreaming.set -> void
+Dapper.ProviderTools.DbConnectionExtensions
+Dapper.ProviderTools.DbExceptionExtensions
+static Dapper.ProviderTools.BulkCopy.Create(System.Data.Common.DbConnection! connection) -> Dapper.ProviderTools.BulkCopy!
+static Dapper.ProviderTools.BulkCopy.TryCreate(System.Data.Common.DbConnection! connection) -> Dapper.ProviderTools.BulkCopy?
+static Dapper.ProviderTools.DbConnectionExtensions.TryClearAllPools(this System.Data.Common.DbConnection! connection) -> bool
+static Dapper.ProviderTools.DbConnectionExtensions.TryClearPool(this System.Data.Common.DbConnection! connection) -> bool
+static Dapper.ProviderTools.DbConnectionExtensions.TryGetClientConnectionId(this System.Data.Common.DbConnection! connection, out System.Guid clientConnectionId) -> bool
+static Dapper.ProviderTools.DbExceptionExtensions.IsNumber(this System.Data.Common.DbException! exception, int number) -> bool
\ No newline at end of file

Dapper.ProviderTools/PublicAPI.Unshipped.txt

+#nullable enable
\ No newline at end of file

Dapper.Rainbow/Dapper.Rainbow.csproj

@@ -14,7 +14,7 @@
     <ProjectReference Include="..\Dapper\Dapper.csproj" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
-    <PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
+    <PackageReference Include="Microsoft.CSharp" />
   </ItemGroup>
   <ItemGroup Condition=" '$(TargetFramework)' == 'net461' ">
     <Reference Include="Microsoft.CSharp" />

Dapper.SqlBuilder/Dapper.SqlBuilder.csproj

@@ -8,12 +8,18 @@
     <TargetFrameworks>net461;netstandard2.0;net5.0</TargetFrameworks>
     <GenerateDocumentationFile>false</GenerateDocumentationFile>
     <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
+    <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
     <ProjectReference Include="..\Dapper\Dapper.csproj" />
+
+    <PackageReference Include="Microsoft.CodeAnalysis.PublicApiAnalyzers">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
-    <PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
+    <PackageReference Include="Microsoft.CSharp" />
   </ItemGroup>
   <ItemGroup Condition=" '$(TargetFramework)' == 'net461' ">
     <Reference Include="Microsoft.CSharp" />

Dapper.SqlBuilder/PublicAPI.Shipped.txt

+#nullable enable
+Dapper.SqlBuilder
+Dapper.SqlBuilder.AddClause(string! name, string! sql, object? parameters, string! joiner, string! prefix = "", string! postfix = "", bool isInclusive = false) -> Dapper.SqlBuilder!
+Dapper.SqlBuilder.AddParameters(dynamic! parameters) -> Dapper.SqlBuilder!
+Dapper.SqlBuilder.AddTemplate(string! sql, dynamic? parameters = null) -> Dapper.SqlBuilder.Template!
+Dapper.SqlBuilder.GroupBy(string! sql, dynamic? parameters = null) -> Dapper.SqlBuilder!
+Dapper.SqlBuilder.Having(string! sql, dynamic? parameters = null) -> Dapper.SqlBuilder!
+Dapper.SqlBuilder.InnerJoin(string! sql, dynamic? parameters = null) -> Dapper.SqlBuilder!
+Dapper.SqlBuilder.Intersect(string! sql, dynamic? parameters = null) -> Dapper.SqlBuilder!
+Dapper.SqlBuilder.Join(string! sql, dynamic? parameters = null) -> Dapper.SqlBuilder!
+Dapper.SqlBuilder.LeftJoin(string! sql, dynamic? parameters = null) -> Dapper.SqlBuilder!
+Dapper.SqlBuilder.OrderBy(string! sql, dynamic? parameters = null) -> Dapper.SqlBuilder!
+Dapper.SqlBuilder.OrWhere(string! sql, dynamic? parameters = null) -> Dapper.SqlBuilder!
+Dapper.SqlBuilder.RightJoin(string! sql, dynamic? parameters = null) -> Dapper.SqlBuilder!
+Dapper.SqlBuilder.Select(string! sql, dynamic? parameters = null) -> Dapper.SqlBuilder!
+Dapper.SqlBuilder.Set(string! sql, dynamic? parameters = null) -> Dapper.SqlBuilder!
+Dapper.SqlBuilder.SqlBuilder() -> void
+Dapper.SqlBuilder.Template
+Dapper.SqlBuilder.Template.Parameters.get -> object?
+Dapper.SqlBuilder.Template.RawSql.get -> string!
+Dapper.SqlBuilder.Template.Template(Dapper.SqlBuilder! builder, string! sql, dynamic? parameters) -> void
+Dapper.SqlBuilder.Where(string! sql, dynamic? parameters = null) -> Dapper.SqlBuilder!
\ No newline at end of file

Dapper.SqlBuilder/PublicAPI.Unshipped.txt

+#nullable enable
\ No newline at end of file

Dapper.SqlBuilder/SqlBuilder.cs

 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Text.RegularExpressions;
 
@@ -11,9 +12,15 @@ public class SqlBuilder
 
         private class Clause
         {
-            public string Sql { get; set; }
-            public object Parameters { get; set; }
-            public bool IsInclusive { get; set; }
+            public Clause(string sql, object? parameters, bool isInclusive)
+            {
+                Sql = sql;
+                Parameters = parameters;
+                IsInclusive = isInclusive;
+            }
+            public string Sql { get; }
+            public object? Parameters { get; }
+            public bool IsInclusive { get; }
         }
 
         private class Clauses : List<Clause>
@@ -52,10 +59,10 @@ public class Template
         {
             private readonly string _sql;
             private readonly SqlBuilder _builder;
-            private readonly object _initParams;
+            private readonly object? _initParams;
             private int _dataSeq = -1; // Unresolved
 
-            public Template(SqlBuilder builder, string sql, dynamic parameters)
+            public Template(SqlBuilder builder, string sql, dynamic? parameters)
             {
                 _initParams = parameters;
                 _sql = sql;
@@ -85,73 +92,73 @@ private void ResolveSql()
                 }
             }
 
-            private string rawSql;
-            private object parameters;
+            private string? rawSql;
+            private object? parameters;
 
             public string RawSql
             {
-                get { ResolveSql(); return rawSql; }
+                get { ResolveSql(); return rawSql!; }
             }
 
-            public object Parameters
+            public object? Parameters
             {
                 get { ResolveSql(); return parameters; }
             }
         }
 
-        public Template AddTemplate(string sql, dynamic parameters = null) =>
-            new Template(this, sql, parameters);
+        public Template AddTemplate(string sql, dynamic? parameters = null) =>
+            new Template(this, sql, (object?)parameters);
 
-        protected SqlBuilder AddClause(string name, string sql, object parameters, string joiner, string prefix = "", string postfix = "", bool isInclusive = false)
+        protected SqlBuilder AddClause(string name, string sql, object? parameters, string joiner, string prefix = "", string postfix = "", bool isInclusive = false)
         {
-            if (!_data.TryGetValue(name, out Clauses clauses))
+            if (!_data.TryGetValue(name, out var clauses))
             {
                 clauses = new Clauses(joiner, prefix, postfix);
                 _data[name] = clauses;
             }
-            clauses.Add(new Clause { Sql = sql, Parameters = parameters, IsInclusive = isInclusive });
+            clauses.Add(new Clause(sql, parameters, isInclusive));
             _seq++;
             return this;
         }
 
-        public SqlBuilder Intersect(string sql, dynamic parameters = null) =>
-            AddClause("intersect", sql, parameters, "\nINTERSECT\n ", "\n ", "\n", false);
+        public SqlBuilder Intersect(string sql, dynamic? parameters = null) =>
+            AddClause("intersect", sql, (object?)parameters, "\nINTERSECT\n ", "\n ", "\n", false);
 
-        public SqlBuilder InnerJoin(string sql, dynamic parameters = null) =>
-            AddClause("innerjoin", sql, parameters, "\nINNER JOIN ", "\nINNER JOIN ", "\n", false);
+        public SqlBuilder InnerJoin(string sql, dynamic? parameters = null) =>
+            AddClause("innerjoin", sql, (object?)parameters, "\nINNER JOIN ", "\nINNER JOIN ", "\n", false);
 
-        public SqlBuilder LeftJoin(string sql, dynamic parameters = null) =>
-            AddClause("leftjoin", sql, parameters, "\nLEFT JOIN ", "\nLEFT JOIN ", "\n", false);
+        public SqlBuilder LeftJoin(string sql, dynamic? parameters = null) =>
+            AddClause("leftjoin", sql, (object?)parameters, "\nLEFT JOIN ", "\nLEFT JOIN ", "\n", false);
 
-        public SqlBuilder RightJoin(string sql, dynamic parameters = null) =>
-            AddClause("rightjoin", sql, parameters, "\nRIGHT JOIN ", "\nRIGHT JOIN ", "\n", false);
+        public SqlBuilder RightJoin(string sql, dynamic? parameters = null) =>
+            AddClause("rightjoin", sql, (object?)parameters, "\nRIGHT JOIN ", "\nRIGHT JOIN ", "\n", false);
 
-        public SqlBuilder Where(string sql, dynamic parameters = null) =>
-            AddClause("where", sql, parameters, " AND ", "WHERE ", "\n", false);
+        public SqlBuilder Where(string sql, dynamic? parameters = null) =>
+            AddClause("where", sql, (object?)parameters, " AND ", "WHERE ", "\n", false);
 
-        public SqlBuilder OrWhere(string sql, dynamic parameters = null) =>
-            AddClause("where", sql, parameters, " OR ", "WHERE ", "\n", true);
+        public SqlBuilder OrWhere(string sql, dynamic? parameters = null) =>
+            AddClause("where", sql, (object?)parameters, " OR ", "WHERE ", "\n", true);
 
-        public SqlBuilder OrderBy(string sql, dynamic parameters = null) =>
-            AddClause("orderby", sql, parameters, " , ", "ORDER BY ", "\n", false);
+        public SqlBuilder OrderBy(string sql, dynamic? parameters = null) =>
+            AddClause("orderby", sql, (object?)parameters, " , ", "ORDER BY ", "\n", false);
 
-        public SqlBuilder Select(string sql, dynamic parameters = null) =>
-            AddClause("select", sql, parameters, " , ", "", "\n", false);
+        public SqlBuilder Select(string sql, dynamic? parameters = null) =>
+            AddClause("select", sql, (object?)parameters, " , ", "", "\n", false);
 
         public SqlBuilder AddParameters(dynamic parameters) =>
-            AddClause("--parameters", "", parameters, "", "", "", false);
+            AddClause("--parameters", "", (object?)parameters, "", "", "", false);
 
-        public SqlBuilder Join(string sql, dynamic parameters = null) =>
-            AddClause("join", sql, parameters, "\nJOIN ", "\nJOIN ", "\n", false);
+        public SqlBuilder Join(string sql, dynamic? parameters = null) =>
+            AddClause("join", sql, (object?)parameters, "\nJOIN ", "\nJOIN ", "\n", false);
 
-        public SqlBuilder GroupBy(string sql, dynamic parameters = null) =>
-            AddClause("groupby", sql, parameters, " , ", "\nGROUP BY ", "\n", false);
+        public SqlBuilder GroupBy(string sql, dynamic? parameters = null) =>
+            AddClause("groupby", sql, (object?)parameters, " , ", "\nGROUP BY ", "\n", false);
 
-        public SqlBuilder Having(string sql, dynamic parameters = null) =>
-            AddClause("having", sql, parameters, "\nAND ", "HAVING ", "\n", false);
+        public SqlBuilder Having(string sql, dynamic? parameters = null) =>
+            AddClause("having", sql, (object?)parameters, "\nAND ", "HAVING ", "\n", false);
 
-        public SqlBuilder Set(string sql, dynamic parameters = null) =>
-             AddClause("set", sql, parameters, " , ", "SET ", "\n", false);
+        public SqlBuilder Set(string sql, dynamic? parameters = null) =>
+             AddClause("set", sql, (object?)parameters, " , ", "SET ", "\n", false);
 
     }
 }

Dapper.StrongName/Dapper.StrongName.csproj

@@ -8,17 +8,15 @@
     <TargetFrameworks>net461;netstandard2.0;net5.0</TargetFrameworks>
     <SignAssembly>true</SignAssembly>
     <PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
+    <Nullable>enable</Nullable>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <ItemGroup>
     <Folder Include="Properties\" />
     <Compile Include="..\Dapper\**\*.cs" Exclude="..\Dapper\obj\**\*.cs" />
   </ItemGroup>
 
-  <PropertyGroup Condition=" '$(TargetFramework)' == 'net5.0'">
-    <DefineConstants>$(DefineConstants);PLAT_NO_REMOTING;PLAT_SKIP_LOCALS_INIT</DefineConstants>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-  </PropertyGroup>
   <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
-    <PackageReference Include="System.Reflection.Emit.Lightweight" Version="4.7.0" />
+    <PackageReference Include="System.Reflection.Emit.Lightweight" />
   </ItemGroup>
 </Project>

Dapper.sln

 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.28917.182
+# Visual Studio Version 17
+VisualStudioVersion = 17.7.33906.173
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{A34907DF-958A-4E4C-8491-84CF303FD13E}"
 	ProjectSection(SolutionItems) = preProject
 		.editorconfig = .editorconfig
 		appveyor.yml = appveyor.yml
+		Build.csproj = Build.csproj
 		build.ps1 = build.ps1
 		Dapper.png = Dapper.png
 		Directory.Build.props = Directory.Build.props
+		Directory.Packages.props = Directory.Packages.props
 		global.json = global.json
 		docs\index.md = docs\index.md
 		License.txt = License.txt
@@ -31,9 +33,6 @@ EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Dapper.Rainbow", "Dapper.Rainbow\Dapper.Rainbow.csproj", "{8A74F0B6-188F-45D2-8A4B-51E4F211805A}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{4E956F6B-6BD8-46F5-BC85-49292FF8F9AB}"
-	ProjectSection(SolutionItems) = preProject
-		Directory.Build.props = Directory.Build.props
-	EndProjectSection
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{568BD46C-1C65-4D44-870C-12CD72563262}"
 	ProjectSection(SolutionItems) = preProject
@@ -51,6 +50,7 @@ EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "docs", "docs", "{9D960D4D-80A2-4DAC-B386-8F4235EC73E6}"
 	ProjectSection(SolutionItems) = preProject
 		docs\index.md = docs\index.md
+		docs\readme.md = docs\readme.md
 	EndProjectSection
 EndProject
 Global

Dapper/CommandDefinition.cs

@@ -11,7 +11,7 @@ namespace Dapper
     /// </summary>
     public readonly struct CommandDefinition
     {
-        internal static CommandDefinition ForCallback(object parameters)
+        internal static CommandDefinition ForCallback(object? parameters)
         {
             if (parameters is DynamicParameters)
             {
@@ -36,12 +36,12 @@ internal void OnCompleted()
         /// <summary>
         /// The parameters associated with the command
         /// </summary>
-        public object Parameters { get; }
+        public object? Parameters { get; }
 
         /// <summary>
         /// The active transaction for the command
         /// </summary>
-        public IDbTransaction Transaction { get; }
+        public IDbTransaction? Transaction { get; }
 
         /// <summary>
         /// The effective timeout for the command
@@ -83,7 +83,7 @@ internal void OnCompleted()
         /// <param name="commandType">The <see cref="CommandType"/> for this command.</param>
         /// <param name="flags">The behavior flags for this command.</param>
         /// <param name="cancellationToken">The cancellation token for this command.</param>
-        public CommandDefinition(string commandText, object parameters = null, IDbTransaction transaction = null, int? commandTimeout = null,
+        public CommandDefinition(string commandText, object? parameters = null, IDbTransaction? transaction = null, int? commandTimeout = null,
                                  CommandType? commandType = null, CommandFlags flags = CommandFlags.Buffered
                                  , CancellationToken cancellationToken = default
             )
@@ -97,9 +97,10 @@ internal void OnCompleted()
             CancellationToken = cancellationToken;
         }
 
-        private CommandDefinition(object parameters) : this()
+        private CommandDefinition(object? parameters) : this()
         {
             Parameters = parameters;
+            CommandText = "";
         }
 
         /// <summary>
@@ -107,12 +108,12 @@ private CommandDefinition(object parameters) : this()
         /// </summary>
         public CancellationToken CancellationToken { get; }
 
-        internal IDbCommand SetupCommand(IDbConnection cnn, Action<IDbCommand, object> paramReader)
+        internal IDbCommand SetupCommand(IDbConnection cnn, Action<IDbCommand, object?>? paramReader)
         {
             var cmd = cnn.CreateCommand();
             var init = GetInit(cmd.GetType());
             init?.Invoke(cmd);
-            if (Transaction != null)
+            if (Transaction is not null)
                 cmd.Transaction = Transaction;
             cmd.CommandText = CommandText;
             if (CommandTimeout.HasValue)
@@ -129,26 +130,30 @@ internal IDbCommand SetupCommand(IDbConnection cnn, Action<IDbCommand, object> p
             return cmd;
         }
 
-        private static SqlMapper.Link<Type, Action<IDbCommand>> commandInitCache;
+        private static SqlMapper.Link<Type, Action<IDbCommand>>? commandInitCache;
 
-        private static Action<IDbCommand> GetInit(Type commandType)
+        internal static void ResetCommandInitCache()
+            => SqlMapper.Link<Type, Action<IDbCommand>>.Clear(ref commandInitCache);
+
+        private static Action<IDbCommand>? GetInit(Type commandType)
         {
-            if (commandType == null)
+            if (commandType is null)
                 return null; // GIGO
-            if (SqlMapper.Link<Type, Action<IDbCommand>>.TryGet(commandInitCache, commandType, out Action<IDbCommand> action))
+            if (SqlMapper.Link<Type, Action<IDbCommand>>.TryGet(commandInitCache, commandType, out Action<IDbCommand>? action))
             {
                 return action;
             }
             var bindByName = GetBasicPropertySetter(commandType, "BindByName", typeof(bool));
             var initialLongFetchSize = GetBasicPropertySetter(commandType, "InitialLONGFetchSize", typeof(int));
+            var fetchSize = GetBasicPropertySetter(commandType, "FetchSize", typeof(long));
 
             action = null;
-            if (bindByName != null || initialLongFetchSize != null)
+            if (bindByName is not null || initialLongFetchSize is not null || fetchSize is not null)
             {
                 var method = new DynamicMethod(commandType.Name + "_init", null, new Type[] { typeof(IDbCommand) });
                 var il = method.GetILGenerator();
 
-                if (bindByName != null)
+                if (bindByName is not null)
                 {
                     // .BindByName = true
                     il.Emit(OpCodes.Ldarg_0);
@@ -156,7 +161,7 @@ private static Action<IDbCommand> GetInit(Type commandType)
                     il.Emit(OpCodes.Ldc_I4_1);
                     il.EmitCall(OpCodes.Callvirt, bindByName, null);
                 }
-                if (initialLongFetchSize != null)
+                if (initialLongFetchSize is not null)
                 {
                     // .InitialLONGFetchSize = -1
                     il.Emit(OpCodes.Ldarg_0);
@@ -164,15 +169,27 @@ private static Action<IDbCommand> GetInit(Type commandType)
                     il.Emit(OpCodes.Ldc_I4_M1);
                     il.EmitCall(OpCodes.Callvirt, initialLongFetchSize, null);
                 }
+                if (fetchSize is not null)
+                {
+                    var snapshot = SqlMapper.Settings.FetchSize;
+                    if (snapshot >= 0)
+                    {
+                        // .FetchSize = {withValue}
+                        il.Emit(OpCodes.Ldarg_0);
+                        il.Emit(OpCodes.Castclass, commandType);
+                        il.Emit(OpCodes.Ldc_I8, snapshot); // bake it as a constant
+                        il.EmitCall(OpCodes.Callvirt, fetchSize, null);
+                    }
+                }
                 il.Emit(OpCodes.Ret);
                 action = (Action<IDbCommand>)method.CreateDelegate(typeof(Action<IDbCommand>));
             }
             // cache it
-            SqlMapper.Link<Type, Action<IDbCommand>>.TryAdd(ref commandInitCache, commandType, ref action);
+            SqlMapper.Link<Type, Action<IDbCommand>>.TryAdd(ref commandInitCache, commandType, ref action!);
             return action;
         }
 
-        private static MethodInfo GetBasicPropertySetter(Type declaringType, string name, Type expectedType)
+        private static MethodInfo? GetBasicPropertySetter(Type declaringType, string name, Type expectedType)
         {
             var prop = declaringType.GetProperty(name, BindingFlags.Public | BindingFlags.Instance);
             if (prop?.CanWrite == true && prop.PropertyType == expectedType && prop.GetIndexParameters().Length == 0)

Dapper/CustomPropertyTypeMap.cs

@@ -28,14 +28,14 @@ public CustomPropertyTypeMap(Type type, Func<Type, string, PropertyInfo> propert
         /// <param name="names">DataReader column names</param>
         /// <param name="types">DataReader column types</param>
         /// <returns>Default constructor</returns>
-        public ConstructorInfo FindConstructor(string[] names, Type[] types) =>
-            _type.GetConstructor(Array.Empty<Type>());
+        public ConstructorInfo? FindConstructor(string[] names, Type[] types) =>
+            _type.GetConstructor(Array.Empty<Type>())!;
 
         /// <summary>
         /// Always returns null
         /// </summary>
         /// <returns></returns>
-        public ConstructorInfo FindExplicitConstructor() => null;
+        public ConstructorInfo? FindExplicitConstructor() => null;
 
         /// <summary>
         /// Not implemented as far as default constructor used for all cases
@@ -53,10 +53,10 @@ public SqlMapper.IMemberMap GetConstructorParameter(ConstructorInfo constructor,
         /// </summary>
         /// <param name="columnName">DataReader column name</param>
         /// <returns>Property member map</returns>
-        public SqlMapper.IMemberMap GetMember(string columnName)
+        public SqlMapper.IMemberMap? GetMember(string columnName)
         {
             var prop = _propertySelector(_type, columnName);
-            return prop != null ? new SimpleMemberMap(columnName, prop) : null;
+            return prop is not null ? new SimpleMemberMap(columnName, prop) : null;
         }
     }
 }

Dapper/Dapper.csproj

@@ -6,16 +6,25 @@
     <Description>A high performance Micro-ORM supporting SQL Server, MySQL, Sqlite, SqlCE, Firebird etc..</Description>
     <Authors>Sam Saffron;Marc Gravell;Nick Craver</Authors>
     <TargetFrameworks>net461;netstandard2.0;net5.0</TargetFrameworks>
+    <Nullable>enable</Nullable>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
+  <ItemGroup>
+    <!-- common base API goes here -->
+    <AdditionalFiles Include="PublicAPI.*.txt" />
+    <!-- TFM-specific additions go here; in reality this just means "current" (to avoid DisposeAsync etc in netfx/netstandard) -->
+    <AdditionalFiles Include="PublicAPI/$(TargetFramework)/PublicAPI.*.txt" />
+  </ItemGroup>
   <ItemGroup>
     <Folder Include="Properties\" />
+
+    <PackageReference Include="Microsoft.CodeAnalysis.PublicApiAnalyzers">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
   </ItemGroup>
 
-  <PropertyGroup Condition=" '$(TargetFramework)' == 'net5.0'">
-    <DefineConstants>$(DefineConstants);PLAT_NO_REMOTING;PLAT_SKIP_LOCALS_INIT</DefineConstants>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-  </PropertyGroup>
   <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
-    <PackageReference Include="System.Reflection.Emit.Lightweight" Version="4.7.0" />
+    <PackageReference Include="System.Reflection.Emit.Lightweight" />
   </ItemGroup>
 </Project>

Dapper/DbString.cs

@@ -43,7 +43,7 @@ public DbString()
         /// <summary>
         /// The value of the string
         /// </summary>
-        public string Value { get; set; }
+        public string? Value { get; set; }
         
         /// <summary>
         /// Gets a string representation of this DbString.
@@ -76,7 +76,7 @@ public void AddParameter(IDbCommand command, string name)
 #pragma warning disable 0618
             param.Value = SqlMapper.SanitizeParameterValue(Value);
 #pragma warning restore 0618
-            if (Length == -1 && Value != null && Value.Length <= DefaultLength)
+            if (Length == -1 && Value is not null && Value.Length <= DefaultLength)
             {
                 param.Size = DefaultLength;
             }

Dapper/DefaultTypeMap.cs

@@ -19,7 +19,7 @@ public sealed class DefaultTypeMap : SqlMapper.ITypeMap
         /// <param name="type">Entity type</param>
         public DefaultTypeMap(Type type)
         {
-            if (type == null)
+            if (type is null)
                 throw new ArgumentNullException(nameof(type));
 
             _fields = GetSettableFields(type);
@@ -27,24 +27,30 @@ public DefaultTypeMap(Type type)
             _type = type;
         }
 
-        internal static MethodInfo GetPropertySetter(PropertyInfo propertyInfo, Type type)
+        internal static MethodInfo GetPropertySetterOrThrow(PropertyInfo propertyInfo, Type type)
+        {
+            return GetPropertySetter(propertyInfo, type) ?? Throw(propertyInfo);
+
+            static MethodInfo Throw(PropertyInfo propertyInfo) => throw new InvalidOperationException("Property setting not found for: " + propertyInfo?.Name);
+        }
+        internal static MethodInfo? GetPropertySetter(PropertyInfo propertyInfo, Type type)
         {
             if (propertyInfo.DeclaringType == type) return propertyInfo.GetSetMethod(true);
 
-            return propertyInfo.DeclaringType.GetProperty(
+            return propertyInfo.DeclaringType!.GetProperty(
                    propertyInfo.Name,
                    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance,
                    Type.DefaultBinder,
                    propertyInfo.PropertyType,
                    propertyInfo.GetIndexParameters().Select(p => p.ParameterType).ToArray(),
-                   null).GetSetMethod(true);
+                   null)!.GetSetMethod(true);
         }
 
         internal static List<PropertyInfo> GetSettableProps(Type t)
         {
             return t
                   .GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
-                  .Where(p => GetPropertySetter(p, t) != null)
+                  .Where(p => GetPropertySetter(p, t) is not null)
                   .ToList();
         }
 
@@ -59,7 +65,7 @@ internal static List<FieldInfo> GetSettableFields(Type t)
         /// <param name="names">DataReader column names</param>
         /// <param name="types">DataReader column types</param>
         /// <returns>Matching constructor or default one</returns>
-        public ConstructorInfo FindConstructor(string[] names, Type[] types)
+        public ConstructorInfo? FindConstructor(string[] names, Type[] types)
         {
             var constructors = _type.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
             foreach (ConstructorInfo ctor in constructors.OrderBy(c => c.IsPublic ? 0 : (c.IsPrivate ? 2 : 1)).ThenBy(c => c.GetParameters().Length))
@@ -74,8 +80,16 @@ public ConstructorInfo FindConstructor(string[] names, Type[] types)
                 int i = 0;
                 for (; i < ctorParameters.Length; i++)
                 {
-                    if (!string.Equals(ctorParameters[i].Name, names[i], StringComparison.OrdinalIgnoreCase))
+                    if (EqualsCI(ctorParameters[i].Name, names[i]))
+                    { } // exact match
+                    else if (MatchNamesWithUnderscores && EqualsCIU(ctorParameters[i].Name, names[i]))
+                    { } // match after applying underscores
+                    else
+                    {
+                        // not a name match
                         break;
+                    }
+
                     if (types[i] == typeof(byte[]) && ctorParameters[i].ParameterType.FullName == SqlMapper.LinqBinary)
                         continue;
                     var unboxedType = Nullable.GetUnderlyingType(ctorParameters[i].ParameterType) ?? ctorParameters[i].ParameterType;
@@ -98,7 +112,7 @@ public ConstructorInfo FindConstructor(string[] names, Type[] types)
         /// <summary>
         /// Returns the constructor, if any, that has the ExplicitConstructorAttribute on it.
         /// </summary>
-        public ConstructorInfo FindExplicitConstructor()
+        public ConstructorInfo? FindExplicitConstructor()
         {
             var constructors = _type.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
             var withAttr = constructors.Where(c => c.GetCustomAttributes(typeof(ExplicitConstructorAttribute), true).Length > 0).ToList();
@@ -119,9 +133,10 @@ public ConstructorInfo FindExplicitConstructor()
         /// <returns>Mapping implementation</returns>
         public SqlMapper.IMemberMap GetConstructorParameter(ConstructorInfo constructor, string columnName)
         {
-            var parameters = constructor.GetParameters();
+            var param = MatchFirstOrDefault(constructor.GetParameters(), columnName, static p => p.Name) ?? Throw(columnName);
+            return new SimpleMemberMap(columnName, param);
 
-            return new SimpleMemberMap(columnName, parameters.FirstOrDefault(p => string.Equals(p.Name, columnName, StringComparison.OrdinalIgnoreCase)));
+            static ParameterInfo Throw(string name) => throw new ArgumentException("Constructor parameter not found for " + name);
         }
 
         /// <summary>
@@ -129,18 +144,11 @@ public SqlMapper.IMemberMap GetConstructorParameter(ConstructorInfo constructor,
         /// </summary>
         /// <param name="columnName">DataReader column name</param>
         /// <returns>Mapping implementation</returns>
-        public SqlMapper.IMemberMap GetMember(string columnName)
+        public SqlMapper.IMemberMap? GetMember(string columnName)
         {
-            var property = Properties.Find(p => string.Equals(p.Name, columnName, StringComparison.Ordinal))
-               ?? Properties.Find(p => string.Equals(p.Name, columnName, StringComparison.OrdinalIgnoreCase));
+            var property = MatchFirstOrDefault(Properties, columnName, static p => p.Name);
 
-            if (property == null && MatchNamesWithUnderscores)
-            {
-                property = Properties.Find(p => string.Equals(p.Name, columnName.Replace("_", ""), StringComparison.Ordinal))
-                    ?? Properties.Find(p => string.Equals(p.Name, columnName.Replace("_", ""), StringComparison.OrdinalIgnoreCase));
-            }
-
-            if (property != null)
+            if (property is not null)
                 return new SimpleMemberMap(columnName, property);
 
             // roslyn automatically implemented properties, in particular for get-only properties: <{Name}>k__BackingField;
@@ -153,7 +161,7 @@ public SqlMapper.IMemberMap GetMember(string columnName)
                 ?? _fields.Find(p => string.Equals(p.Name, columnName, StringComparison.OrdinalIgnoreCase))
                 ?? _fields.Find(p => string.Equals(p.Name, backingFieldName, StringComparison.OrdinalIgnoreCase));
 
-            if (field == null && MatchNamesWithUnderscores)
+            if (field is null && MatchNamesWithUnderscores)
             {
                 var effectiveColumnName = columnName.Replace("_", "");
                 backingFieldName = "<" + effectiveColumnName + ">k__BackingField";
@@ -164,7 +172,7 @@ public SqlMapper.IMemberMap GetMember(string columnName)
                     ?? _fields.Find(p => string.Equals(p.Name, backingFieldName, StringComparison.OrdinalIgnoreCase));
             }
 
-            if (field != null)
+            if (field is not null)
                 return new SimpleMemberMap(columnName, field);
 
             return null;
@@ -174,6 +182,54 @@ public SqlMapper.IMemberMap GetMember(string columnName)
         /// </summary>
         public static bool MatchNamesWithUnderscores { get; set; }
 
+        static T? MatchFirstOrDefault<T>(IList<T>? members, string? name, Func<T, string?> selector) where T : class
+        {
+            if (members is { Count: > 0 })
+            {
+                // try exact first
+                foreach (var member in members)
+                {
+                    if (string.Equals(name, selector(member), StringComparison.Ordinal))
+                    {
+                        return member;
+                    }
+                }
+                // then exact ignoring case
+                foreach (var member in members)
+                {
+                    if (string.Equals(name, selector(member), StringComparison.OrdinalIgnoreCase))
+                    {
+                        return member;
+                    }
+                }
+                if (MatchNamesWithUnderscores)
+                {
+                    // same again, minus underscore delta
+                    name = name?.Replace("_", "");
+                    foreach (var member in members)
+                    {
+                        if (string.Equals(name, selector(member)?.Replace("_", ""), StringComparison.Ordinal))
+                        {
+                            return member;
+                        }
+                    }
+                    foreach (var member in members)
+                    {
+                        if (string.Equals(name, selector(member)?.Replace("_", ""), StringComparison.OrdinalIgnoreCase))
+                        {
+                            return member;
+                        }
+                    }
+                }
+            }
+            return null;
+        }
+
+        internal static bool EqualsCI(string? x, string? y)
+            => string.Equals(x, y, StringComparison.OrdinalIgnoreCase);
+        internal static bool EqualsCIU(string? x, string? y)
+            => string.Equals(x?.Replace("_", ""), y?.Replace("_", ""), StringComparison.OrdinalIgnoreCase);
+
         /// <summary>
         /// The settable properties for this typemap
         /// </summary>

Dapper/DynamicParameters.ParamInfo.cs

@@ -7,14 +7,14 @@ public partial class DynamicParameters
     {
         private sealed class ParamInfo
         {
-            public string Name { get; set; }
-            public object Value { get; set; }
+            public string Name { get; set; } = null!;
+            public object? Value { get; set; }
             public ParameterDirection ParameterDirection { get; set; }
             public DbType? DbType { get; set; }
             public int? Size { get; set; }
-            public IDbDataParameter AttachedParam { get; set; }
-            internal Action<object, DynamicParameters> OutputCallback { get; set; }
-            internal object OutputTarget { get; set; }
+            public IDbDataParameter AttachedParam { get; set; } = null!;
+            internal Action<object, DynamicParameters>? OutputCallback { get; set; }
+            internal object OutputTarget { get; set; } = null!;
             internal bool CameFromTemplate { get; set; }
 
             public byte? Precision { get; set; }

Dapper/DynamicParameters.cs

@@ -16,10 +16,10 @@ public partial class DynamicParameters : SqlMapper.IDynamicParameters, SqlMapper
         internal const DbType EnumerableMultiParameter = (DbType)(-1);
         private static readonly Dictionary<SqlMapper.Identity, Action<IDbCommand, object>> paramReaderCache = new Dictionary<SqlMapper.Identity, Action<IDbCommand, object>>();
         private readonly Dictionary<string, ParamInfo> parameters = new Dictionary<string, ParamInfo>();
-        private List<object> templates;
+        private List<object>? templates;
 
-        object SqlMapper.IParameterLookup.this[string name] =>
-            parameters.TryGetValue(name, out ParamInfo param) ? param.Value : null;
+        object? SqlMapper.IParameterLookup.this[string name] =>
+            parameters.TryGetValue(name, out ParamInfo? param) ? param.Value : null;
 
         /// <summary>
         /// construct a dynamic parameter bag
@@ -33,7 +33,7 @@ public DynamicParameters()
         /// construct a dynamic parameter bag
         /// </summary>
         /// <param name="template">can be an anonymous type or a DynamicParameters bag</param>
-        public DynamicParameters(object template)
+        public DynamicParameters(object? template)
         {
             RemoveUnused = true;
             AddDynamicParams(template);
@@ -44,14 +44,14 @@ public DynamicParameters(object template)
         /// EG: AddDynamicParams(new {A = 1, B = 2}) // will add property A and B to the dynamic
         /// </summary>
         /// <param name="param"></param>
-        public void AddDynamicParams(object param)
+        public void AddDynamicParams(object? param)
         {
             var obj = param;
-            if (obj != null)
+            if (obj is not null)
             {
                 if (obj is DynamicParameters subDynamic)
                 {
-                    if (subDynamic.parameters != null)
+                    if (subDynamic.parameters is not null)
                     {
                         foreach (var kvp in subDynamic.parameters)
                         {
@@ -59,7 +59,7 @@ public void AddDynamicParams(object param)
                         }
                     }
 
-                    if (subDynamic.templates != null)
+                    if (subDynamic.templates is not null)
                     {
                         templates ??= new List<object>();
                         foreach (var t in subDynamic.templates)
@@ -94,7 +94,7 @@ public void AddDynamicParams(object param)
         /// <param name="dbType">The type of the parameter.</param>
         /// <param name="direction">The in or out direction of the parameter.</param>
         /// <param name="size">The size of the parameter.</param>
-        public void Add(string name, object value, DbType? dbType, ParameterDirection? direction, int? size)
+        public void Add(string name, object? value, DbType? dbType, ParameterDirection? direction, int? size)
         {
             parameters[Clean(name)] = new ParamInfo
             {
@@ -116,7 +116,7 @@ public void Add(string name, object value, DbType? dbType, ParameterDirection? d
         /// <param name="size">The size of the parameter.</param>
         /// <param name="precision">The precision of the parameter.</param>
         /// <param name="scale">The scale of the parameter.</param>
-        public void Add(string name, object value = null, DbType? dbType = null, ParameterDirection? direction = null, int? size = null, byte? precision = null, byte? scale = null)
+        public void Add(string name, object? value = null, DbType? dbType = null, ParameterDirection? direction = null, int? size = null, byte? precision = null, byte? scale = null)
         {
             parameters[Clean(name)] = new ParamInfo
             {
@@ -170,7 +170,7 @@ protected void AddParameters(IDbCommand command, SqlMapper.Identity identity)
         {
             var literals = SqlMapper.GetLiteralTokens(identity.sql);
 
-            if (templates != null)
+            if (templates is not null)
             {
                 foreach (var template in templates)
                 {
@@ -179,7 +179,7 @@ protected void AddParameters(IDbCommand command, SqlMapper.Identity identity)
 
                     lock (paramReaderCache)
                     {
-                        if (!paramReaderCache.TryGetValue(newIdent, out appender))
+                        if (!paramReaderCache.TryGetValue(newIdent, out appender!))
                         {
                             appender = SqlMapper.CreateParamInfoGenerator(newIdent, true, RemoveUnused, literals);
                             paramReaderCache[newIdent] = appender;
@@ -213,7 +213,7 @@ protected void AddParameters(IDbCommand command, SqlMapper.Identity identity)
 
                 // Now that the parameters are added to the command, let's place our output callbacks
                 var tmp = outputCallbacks;
-                if (tmp != null)
+                if (tmp is not null)
                 {
                     foreach (var generator in tmp)
                     {
@@ -231,8 +231,8 @@ protected void AddParameters(IDbCommand command, SqlMapper.Identity identity)
                 string name = Clean(param.Name);
                 var isCustomQueryParameter = val is SqlMapper.ICustomQueryParameter;
 
-                SqlMapper.ITypeHandler handler = null;
-                if (dbType == null && val != null && !isCustomQueryParameter)
+                SqlMapper.ITypeHandler? handler = null;
+                if (dbType is null && val is not null && !isCustomQueryParameter)
                 {
 #pragma warning disable 618
                     dbType = SqlMapper.LookupDbType(val.GetType(), name, true, out handler);
@@ -240,7 +240,7 @@ protected void AddParameters(IDbCommand command, SqlMapper.Identity identity)
                 }
                 if (isCustomQueryParameter)
                 {
-                    ((SqlMapper.ICustomQueryParameter)val).AddParameter(command, name);
+                    ((SqlMapper.ICustomQueryParameter)val!).AddParameter(command, name);
                 }
                 else if (dbType == EnumerableMultiParameter)
                 {
@@ -263,7 +263,7 @@ protected void AddParameters(IDbCommand command, SqlMapper.Identity identity)
                     }
 
                     p.Direction = param.ParameterDirection;
-                    if (handler == null)
+                    if (handler is null)
                     {
 #pragma warning disable 0618
                         p.Value = SqlMapper.SanitizeParameterValue(val);
@@ -277,16 +277,16 @@ protected void AddParameters(IDbCommand command, SqlMapper.Identity identity)
                         {
                             p.Size = DbString.DefaultLength;
                         }
-                        if (param.Size != null) p.Size = param.Size.Value;
-                        if (param.Precision != null) p.Precision = param.Precision.Value;
-                        if (param.Scale != null) p.Scale = param.Scale.Value;
+                        if (param.Size is not null) p.Size = param.Size.Value;
+                        if (param.Precision is not null) p.Precision = param.Precision.Value;
+                        if (param.Scale is not null) p.Scale = param.Scale.Value;
                     }
                     else
                     {
                         if (ShouldSetDbType(dbType)) p.DbType = dbType.GetValueOrDefault();
-                        if (param.Size != null) p.Size = param.Size.Value;
-                        if (param.Precision != null) p.Precision = param.Precision.Value;
-                        if (param.Scale != null) p.Scale = param.Scale.Value;
+                        if (param.Size is not null) p.Size = param.Size.Value;
+                        if (param.Precision is not null) p.Precision = param.Precision.Value;
+                        if (param.Scale is not null) p.Scale = param.Scale.Value;
                         handler.SetValue(p, val ?? DBNull.Value);
                     }
 
@@ -317,16 +317,16 @@ public T Get<T>(string name)
         {
             var paramInfo = parameters[Clean(name)];
             var attachedParam = paramInfo.AttachedParam;
-            object val = attachedParam == null ? paramInfo.Value : attachedParam.Value;
+            object? val = attachedParam is null ? paramInfo.Value : attachedParam.Value;
             if (val == DBNull.Value)
             {
-                if (default(T) != null)
+                if (default(T) is not null)
                 {
                     throw new ApplicationException("Attempting to cast a DBNull to a non nullable type! Note that out/return parameters will not have updated values until the data stream completes (after the 'foreach' for Query(..., buffered: false), or after the GridReader has been disposed for QueryMultiple)");
                 }
-                return default;
+                return default!;
             }
-            return (T)val;
+            return (T)val!;
         }
 
         /// <summary>
@@ -339,7 +339,7 @@ public T Get<T>(string name)
         /// <param name="dbType"></param>
         /// <param name="size">The size to set on the parameter. Defaults to 0, or DbString.DefaultLength in case of strings.</param>
         /// <returns>The DynamicParameters instance</returns>
-        public DynamicParameters Output<T>(T target, Expression<Func<T, object>> expression, DbType? dbType = null, int? size = null)
+        public DynamicParameters Output<T>(T target, Expression<Func<T, object?>> expression, DbType? dbType = null, int? size = null)
         {
             static void ThrowInvalidChain()
                 => throw new InvalidOperationException($"Expression must be a property/field chain off of a(n) {typeof(T).Name} instance");
@@ -349,7 +349,7 @@ static void ThrowInvalidChain()
             var lastMemberAccess = expression.Body as MemberExpression;
 #pragma warning restore IDE0019 // Use pattern matching
 
-            if (lastMemberAccess == null
+            if (lastMemberAccess is null
                 || (!(lastMemberAccess.Member is PropertyInfo)
                     && !(lastMemberAccess.Member is FieldInfo)))
             {
@@ -367,10 +367,10 @@ static void ThrowInvalidChain()
             }
 
             // Does the chain consist of MemberExpressions leading to a ParameterExpression of type T?
-            MemberExpression diving = lastMemberAccess;
+            MemberExpression? diving = lastMemberAccess;
             // Retain a list of member names and the member expressions so we can rebuild the chain.
-            List<string> names = new List<string>();
-            List<MemberExpression> chain = new List<MemberExpression>();
+            List<string?> names = new List<string?>();
+            List<MemberExpression?> chain = new List<MemberExpression?>();
 
             do
             {
@@ -384,18 +384,18 @@ static void ThrowInvalidChain()
                 diving = diving?.Expression as MemberExpression;
 #pragma warning restore IDE0019 // use pattern matching
 
-                if (constant is object && constant.Type == typeof(T))
+                if (constant is not null && constant.Type == typeof(T))
                 {
                     break;
                 }
-                else if (diving == null
+                else if (diving is null
                     || (!(diving.Member is PropertyInfo)
                         && !(diving.Member is FieldInfo)))
                 {
                     ThrowInvalidChain();
                 }
             }
-            while (diving != null);
+            while (diving is not null);
 
             var dynamicParamName = string.Concat(names.ToArray());
 
@@ -403,8 +403,8 @@ static void ThrowInvalidChain()
             var lookup = string.Join("|", names.ToArray());
 
             var cache = CachedOutputSetters<T>.Cache;
-            var setter = (Action<object, DynamicParameters>)cache[lookup];
-            if (setter != null) goto MAKECALLBACK;
+            var setter = (Action<object, DynamicParameters>?)cache[lookup];
+            if (setter is not null) goto MAKECALLBACK;
 
             // Come on let's build a method, let's build it, let's build it now!
             var dm = new DynamicMethod("ExpressionParam" + Guid.NewGuid().ToString(), null, new[] { typeof(object), GetType() }, true);
@@ -416,20 +416,20 @@ static void ThrowInvalidChain()
             // Count - 1 to skip the last member access
             for (var i = 0; i < chain.Count - 1; i++)
             {
-                var member = chain[i].Member;
+                var member = chain[i]?.Member;
 
                 if (member is PropertyInfo info)
                 {
                     var get = info.GetGetMethod(true);
-                    il.Emit(OpCodes.Callvirt, get); // [Member{i}]
+                    il.Emit(OpCodes.Callvirt, get!); // [Member{i}]
                 }
                 else // Else it must be a field!
                 {
-                    il.Emit(OpCodes.Ldfld, (FieldInfo)member); // [Member{i}]
+                    il.Emit(OpCodes.Ldfld, (FieldInfo)member!); // [Member{i}]
                 }
             }
 
-            var paramGetter = GetType().GetMethod("Get", new Type[] { typeof(string) }).MakeGenericMethod(lastMemberAccess.Type);
+            var paramGetter = GetType().GetMethod("Get", new Type[] { typeof(string) })!.MakeGenericMethod(lastMemberAccess!.Type);
 
             il.Emit(OpCodes.Ldarg_1); // [target] [DynamicParameters]
             il.Emit(OpCodes.Ldstr, dynamicParamName); // [target] [DynamicParameters] [ParamName]
@@ -440,7 +440,7 @@ static void ThrowInvalidChain()
             if (lastMember is PropertyInfo property)
             {
                 var set = property.GetSetMethod(true);
-                il.Emit(OpCodes.Callvirt, set); // SET
+                il.Emit(OpCodes.Callvirt, set!); // SET
             }
             else
             {
@@ -463,7 +463,7 @@ static void ThrowInvalidChain()
                 var targetMemberType = lastMemberAccess?.Type;
                 int sizeToSet = (!size.HasValue && targetMemberType == typeof(string)) ? DbString.DefaultLength : size ?? 0;
 
-                if (parameters.TryGetValue(dynamicParamName, out ParamInfo parameter))
+                if (parameters.TryGetValue(dynamicParamName, out ParamInfo? parameter))
                 {
                     parameter.ParameterDirection = parameter.AttachedParam.Direction = ParameterDirection.InputOutput;
 
@@ -481,13 +481,13 @@ static void ThrowInvalidChain()
 
                 parameter = parameters[dynamicParamName];
                 parameter.OutputCallback = setter;
-                parameter.OutputTarget = target;
+                parameter.OutputTarget = target!;
             });
 
             return this;
         }
 
-        private List<Action> outputCallbacks;
+        private List<Action>? outputCallbacks;
 
         void SqlMapper.IParameterCallbacks.OnCompleted()
         {

Dapper/Extensions.cs

@@ -22,10 +22,10 @@ internal static class Extensions
             return source.Task;
         }
 
-        private static void OnTaskCompleted<TFrom, TTo>(Task<TFrom> completedTask, object state)
+        private static void OnTaskCompleted<TFrom, TTo>(Task<TFrom> completedTask, object? state)
             where TFrom : TTo
         {
-            var source = (TaskCompletionSource<TTo>)state;
+            var source = (TaskCompletionSource<TTo>)state!;
 
             switch (completedTask.Status)
             {
@@ -36,7 +36,7 @@ internal static class Extensions
                     source.SetCanceled();
                     break;
                 case TaskStatus.Faulted:
-                    source.SetException(completedTask.Exception.InnerExceptions);
+                    source.SetException(completedTask.Exception!.InnerExceptions);
                     break;
             }
         }

Dapper/FeatureSupport.cs

@@ -17,9 +17,9 @@ private static readonly FeatureSupport
         /// Gets the feature set based on the passed connection
         /// </summary>
         /// <param name="connection">The connection to get supported features for.</param>
-        public static FeatureSupport Get(IDbConnection connection)
+        public static FeatureSupport Get(IDbConnection? connection)
         {
-            string name = connection?.GetType().Name;
+            string? name = connection?.GetType().Name;
             if (string.Equals(name, "npgsqlconnection", StringComparison.OrdinalIgnoreCase)) return Postgres;
             if (string.Equals(name, "clickhouseconnection", StringComparison.OrdinalIgnoreCase)) return ClickHouse;
             return Default;

Dapper/NRT.cs

+#if !NET5_0_OR_GREATER
+namespace System.Diagnostics.CodeAnalysis
+{
+    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
+    internal sealed class NotNullWhenAttribute : Attribute
+    {
+        public NotNullWhenAttribute(bool returnValue) => ReturnValue = returnValue;
+
+        public bool ReturnValue { get; }
+    }
+}
+#endif

Dapper/Properties/AssemblyInfo.cs

-
-#if PLAT_SKIP_LOCALS_INIT
-[module: System.Runtime.CompilerServices.SkipLocalsInit]
+[module: System.Runtime.CompilerServices.SkipLocalsInit]
+
+#if !NET5_0_OR_GREATER
+namespace System.Runtime.CompilerServices
+{
+    [AttributeUsage(AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface, Inherited = false)]
+    internal sealed class SkipLocalsInitAttribute : Attribute {}
+}
+namespace System.Diagnostics.CodeAnalysis
+{
+    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
+    internal sealed class MemberNotNullAttribute : Attribute
+    {
+        public MemberNotNullAttribute(string member) {}
+        public MemberNotNullAttribute(params string[] members) {}
+    }
+}
+
 #endif

Dapper/PublicAPI.Unshipped.txt

+#nullable enable
\ No newline at end of file

Dapper/PublicAPI/net461/PublicAPI.Shipped.txt

+#nullable enable
\ No newline at end of file

Dapper/PublicAPI/net461/PublicAPI.Unshipped.txt

+#nullable enable
\ No newline at end of file

Dapper/PublicAPI/net5.0/PublicAPI.Shipped.txt

+#nullable enable
+Dapper.SqlMapper.GridReader.DisposeAsync() -> System.Threading.Tasks.ValueTask
+Dapper.SqlMapper.GridReader.ReadUnbufferedAsync() -> System.Collections.Generic.IAsyncEnumerable<dynamic!>!
+Dapper.SqlMapper.GridReader.ReadUnbufferedAsync<T>() -> System.Collections.Generic.IAsyncEnumerable<T>!
+static Dapper.SqlMapper.QueryUnbufferedAsync(this System.Data.Common.DbConnection! cnn, string! sql, object? param = null, System.Data.Common.DbTransaction? transaction = null, int? commandTimeout = null, System.Data.CommandType? commandType = null) -> System.Collections.Generic.IAsyncEnumerable<dynamic!>!
+static Dapper.SqlMapper.QueryUnbufferedAsync<T>(this System.Data.Common.DbConnection! cnn, string! sql, object? param = null, System.Data.Common.DbTransaction? transaction = null, int? commandTimeout = null, System.Data.CommandType? commandType = null) -> System.Collections.Generic.IAsyncEnumerable<T>!
\ No newline at end of file

Dapper/PublicAPI/net5.0/PublicAPI.Unshipped.txt

+#nullable enable
\ No newline at end of file

Dapper/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt

+#nullable enable
\ No newline at end of file

Dapper/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt

+#nullable enable
\ No newline at end of file

Dapper/SimpleMemberMap.cs

@@ -49,21 +49,21 @@ public SimpleMemberMap(string columnName, ParameterInfo parameter)
         /// <summary>
         /// Target member type
         /// </summary>
-        public Type MemberType => Field?.FieldType ?? Property?.PropertyType ?? Parameter?.ParameterType;
+        public Type MemberType => Field?.FieldType ?? Property?.PropertyType ?? Parameter?.ParameterType!;
 
         /// <summary>
         /// Target property
         /// </summary>
-        public PropertyInfo Property { get; }
+        public PropertyInfo? Property { get; }
 
         /// <summary>
         /// Target field
         /// </summary>
-        public FieldInfo Field { get; }
+        public FieldInfo? Field { get; }
 
         /// <summary>
         /// Target constructor parameter
         /// </summary>
-        public ParameterInfo Parameter { get; }
+        public ParameterInfo? Parameter { get; }
     }
 }

Dapper/SqlDataRecordListTVPParameter.cs

@@ -35,9 +35,9 @@ void SqlMapper.ICustomQueryParameter.AddParameter(IDbCommand command, string nam
             command.Parameters.Add(param);
         }
 
-        internal static void Set(IDbDataParameter parameter, IEnumerable<T> data, string typeName)
+        internal static void Set(IDbDataParameter parameter, IEnumerable<T>? data, string? typeName)
         {
-            parameter.Value = data != null && data.Any() ? data : null;
+            parameter.Value = data is not null && data.Any() ? data : null;
             StructuredHelper.ConfigureTVP(parameter, typeName);
         }
     }
@@ -46,16 +46,16 @@ static class StructuredHelper
         private static readonly Hashtable s_udt = new Hashtable(), s_tvp = new Hashtable();
 
         private static Action<IDbDataParameter, string> GetUDT(Type type)
-            => (Action<IDbDataParameter, string>)s_udt[type] ?? SlowGetHelper(type, s_udt, "UdtTypeName", 29); // 29 = SqlDbType.Udt (avoiding ref)
-        private static Action<IDbDataParameter, string> GetTVP(Type type)
-            => (Action<IDbDataParameter, string>)s_tvp[type] ?? SlowGetHelper(type, s_tvp, "TypeName", 30); // 30 = SqlDbType.Structured (avoiding ref)
+            => (Action<IDbDataParameter, string?>?)s_udt[type] ?? SlowGetHelper(type, s_udt, "UdtTypeName", 29); // 29 = SqlDbType.Udt (avoiding ref)
+        private static Action<IDbDataParameter, string?> GetTVP(Type type)
+            => (Action<IDbDataParameter, string?>?)s_tvp[type] ?? SlowGetHelper(type, s_tvp, "TypeName", 30); // 30 = SqlDbType.Structured (avoiding ref)
 
-        static Action<IDbDataParameter, string> SlowGetHelper(Type type, Hashtable hashtable, string nameProperty, int sqlDbType)
+        static Action<IDbDataParameter, string?> SlowGetHelper(Type type, Hashtable hashtable, string nameProperty, int sqlDbType)
         {
             lock (hashtable)
             {
-                var helper = (Action<IDbDataParameter, string>)hashtable[type];
-                if (helper == null)
+                var helper = (Action<IDbDataParameter, string?>?)hashtable[type];
+                if (helper is null)
                 {
                     helper = CreateFor(type, nameProperty, sqlDbType);
                     hashtable.Add(type, helper);
@@ -64,16 +64,16 @@ static class StructuredHelper
             }
         }
 
-        static Action<IDbDataParameter, string> CreateFor(Type type, string nameProperty, int sqlDbType)
+        static Action<IDbDataParameter, string?> CreateFor(Type type, string nameProperty, int sqlDbType)
         {
             var name = type.GetProperty(nameProperty, BindingFlags.Public | BindingFlags.Instance);
-            if (name == null || !name.CanWrite)
+            if (name is null || !name.CanWrite)
             {
                 return (p, n) => { };
             }
 
             var dbType = type.GetProperty("SqlDbType", BindingFlags.Public | BindingFlags.Instance);
-            if (dbType != null && !dbType.CanWrite) dbType = null;
+            if (dbType is not null && !dbType.CanWrite) dbType = null;
 
             var dm = new DynamicMethod(nameof(CreateFor) + "_" + type.Name, null,
                 new[] { typeof(IDbDataParameter), typeof(string) }, true);
@@ -81,18 +81,18 @@ static class StructuredHelper
             il.Emit(OpCodes.Ldarg_0);
             il.Emit(OpCodes.Castclass, type);
             il.Emit(OpCodes.Ldarg_1);
-            il.EmitCall(OpCodes.Callvirt, name.GetSetMethod(), null);
+            il.EmitCall(OpCodes.Callvirt, name.GetSetMethod()!, null);
 
-            if (dbType != null)
+            if (dbType is not null)
             {
                 il.Emit(OpCodes.Ldarg_0);
                 il.Emit(OpCodes.Castclass, type);
                 il.Emit(OpCodes.Ldc_I4, sqlDbType);
-                il.EmitCall(OpCodes.Callvirt, dbType.GetSetMethod(), null);
+                il.EmitCall(OpCodes.Callvirt, dbType.GetSetMethod()!, null);
             }
 
             il.Emit(OpCodes.Ret);
-            return (Action<IDbDataParameter, string>)dm.CreateDelegate(typeof(Action<IDbDataParameter, string>));
+            return (Action<IDbDataParameter, string?>)dm.CreateDelegate(typeof(Action<IDbDataParameter, string?>));
 
         }
 
@@ -100,7 +100,7 @@ static class StructuredHelper
         // would be a fair option otherwise
         internal static void ConfigureUDT(IDbDataParameter parameter, string typeName)
             => GetUDT(parameter.GetType())(parameter, typeName);
-        internal static void ConfigureTVP(IDbDataParameter parameter, string typeName)
+        internal static void ConfigureTVP(IDbDataParameter parameter, string? typeName)
             => GetTVP(parameter.GetType())(parameter, typeName);
     }
 }

Dapper/SqlMapper.CacheInfo.cs

@@ -10,8 +10,8 @@ public static partial class SqlMapper
         private class CacheInfo
         {
             public DeserializerState Deserializer { get; set; }
-            public Func<DbDataReader, object>[] OtherDeserializers { get; set; }
-            public Action<IDbCommand, object> ParamReader { get; set; }
+            public Func<DbDataReader, object>[]? OtherDeserializers { get; set; }
+            public Action<IDbCommand, object?>? ParamReader { get; set; }
             private int hitCount;
             public int GetHitCount() { return Interlocked.CompareExchange(ref hitCount, 0, 0); }
             public void RecordHit() { Interlocked.Increment(ref hitCount); }

Dapper/SqlMapper.DapperRow.Descriptor.cs

@@ -25,7 +25,7 @@ public override ICustomTypeDescriptor GetTypeDescriptor(Type objectType, object
             //    public DapperRowList(DapperTable table) { _table = table; }
             //    PropertyDescriptorCollection ITypedList.GetItemProperties(PropertyDescriptor[] listAccessors)
             //    {
-            //        if (listAccessors != null && listAccessors.Length != 0) return PropertyDescriptorCollection.Empty;
+            //        if (listAccessors is not null && listAccessors.Length != 0) return PropertyDescriptorCollection.Empty;
 
             //        return DapperRowTypeDescriptor.GetProperties(_table);
             //    }
@@ -42,32 +42,32 @@ public DapperRowTypeDescriptor(object instance)
                 AttributeCollection ICustomTypeDescriptor.GetAttributes()
                     => AttributeCollection.Empty;
 
-                string ICustomTypeDescriptor.GetClassName() => typeof(DapperRow).FullName;
+                string ICustomTypeDescriptor.GetClassName() => typeof(DapperRow).FullName!;
 
-                string ICustomTypeDescriptor.GetComponentName() => null;
+                string ICustomTypeDescriptor.GetComponentName() => null!;
 
                 private static readonly TypeConverter s_converter = new ExpandableObjectConverter();
                 TypeConverter ICustomTypeDescriptor.GetConverter() => s_converter;
 
-                EventDescriptor ICustomTypeDescriptor.GetDefaultEvent() => null;
+                EventDescriptor ICustomTypeDescriptor.GetDefaultEvent() => null!;
 
-                PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty() => null;
+                PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty() => null!;
 
-                object ICustomTypeDescriptor.GetEditor(Type editorBaseType) => null;
+                object ICustomTypeDescriptor.GetEditor(Type editorBaseType) => null!;
 
                 EventDescriptorCollection ICustomTypeDescriptor.GetEvents() => EventDescriptorCollection.Empty;
 
                 EventDescriptorCollection ICustomTypeDescriptor.GetEvents(Attribute[] attributes) => EventDescriptorCollection.Empty;
 
                 internal static PropertyDescriptorCollection GetProperties(DapperRow row) => GetProperties(row?.table, row);
-                internal static PropertyDescriptorCollection GetProperties(DapperTable table, IDictionary<string,object> row = null)
+                internal static PropertyDescriptorCollection GetProperties(DapperTable? table, IDictionary<string,object?>? row = null)
                 {
-                    string[] names = table?.FieldNames;
-                    if (names == null || names.Length == 0) return PropertyDescriptorCollection.Empty;
+                    string[]? names = table?.FieldNames;
+                    if (names is null || names.Length == 0) return PropertyDescriptorCollection.Empty;
                     var arr = new PropertyDescriptor[names.Length];
                     for (int i = 0; i < arr.Length; i++)
                     {
-                        var type = row != null && row.TryGetValue(names[i], out var value) && value != null
+                        var type = row is not null && row.TryGetValue(names[i], out var value) && value is not null
                             ? value.GetType() : typeof(object);
                         arr[i] = new RowBoundPropertyDescriptor(type, names[i], i);
                     }
@@ -97,7 +97,7 @@ public RowBoundPropertyDescriptor(Type type, string name, int index) : base(name
                 public override Type PropertyType => _type;
                 public override object GetValue(object component)
                     => ((DapperRow)component).TryGetValue(_index, out var val) ? (val ?? DBNull.Value): DBNull.Value;
-                public override void SetValue(object component, object value)
+                public override void SetValue(object component, object? value)
                     => ((DapperRow)component).SetValue(_index, value is DBNull ? null : value);
             }
         }

Dapper/SqlMapper.DapperRow.cs

@@ -8,13 +8,13 @@ namespace Dapper
     public static partial class SqlMapper
     {
         private sealed partial class DapperRow
-            : IDictionary<string, object>
-            , IReadOnlyDictionary<string, object>
+            : IDictionary<string, object?>
+            , IReadOnlyDictionary<string, object?>
         {
             private readonly DapperTable table;
-            private object[] values;
+            private object?[] values;
 
-            public DapperRow(DapperTable table, object[] values)
+            public DapperRow(DapperTable table, object?[] values)
             {
                 this.table = table ?? throw new ArgumentNullException(nameof(table));
                 this.values = values ?? throw new ArgumentNullException(nameof(values));
@@ -26,7 +26,7 @@ private sealed class DeadValue
                 private DeadValue() { /* hiding constructor */ }
             }
 
-            int ICollection<KeyValuePair<string, object>>.Count
+            int ICollection<KeyValuePair<string, object?>>.Count
             {
                 get
                 {
@@ -39,10 +39,10 @@ private sealed class DeadValue
                 }
             }
 
-            public bool TryGetValue(string key, out object value)
+            public bool TryGetValue(string key, out object? value)
                 => TryGetValue(table.IndexOfName(key), out value);
 
-            internal bool TryGetValue(int index, out object value)
+            internal bool TryGetValue(int index, out object? value)
             {
                 if (index < 0)
                 { // doesn't exist
@@ -66,7 +66,7 @@ public override string ToString()
                 {
                     var value = kv.Value;
                     sb.Append(", ").Append(kv.Key);
-                    if (value != null)
+                    if (value is not null)
                     {
                         sb.Append(" = '").Append(kv.Value).Append('\'');
                     }
@@ -79,15 +79,15 @@ public override string ToString()
                 return sb.Append('}').ToStringRecycle();
             }
 
-            public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
+            public IEnumerator<KeyValuePair<string, object?>> GetEnumerator()
             {
                 var names = table.FieldNames;
                 for (var i = 0; i < names.Length; i++)
                 {
-                    object value = i < values.Length ? values[i] : null;
+                    object? value = i < values.Length ? values[i] : null!;
                     if (!(value is DeadValue))
                     {
-                        yield return new KeyValuePair<string, object>(names[i], value);
+                        yield return new KeyValuePair<string, object?>(names[i], value);
                     }
                 }
             }
@@ -99,24 +99,24 @@ IEnumerator IEnumerable.GetEnumerator()
 
             #region Implementation of ICollection<KeyValuePair<string,object>>
 
-            void ICollection<KeyValuePair<string, object>>.Add(KeyValuePair<string, object> item)
+            void ICollection<KeyValuePair<string, object?>>.Add(KeyValuePair<string, object?> item)
             {
-                IDictionary<string, object> dic = this;
+                IDictionary<string, object?> dic = this;
                 dic.Add(item.Key, item.Value);
             }
 
-            void ICollection<KeyValuePair<string, object>>.Clear()
+            void ICollection<KeyValuePair<string, object?>>.Clear()
             { // removes values for **this row**, but doesn't change the fundamental table
                 for (int i = 0; i < values.Length; i++)
                     values[i] = DeadValue.Default;
             }
 
-            bool ICollection<KeyValuePair<string, object>>.Contains(KeyValuePair<string, object> item)
+            bool ICollection<KeyValuePair<string, object?>>.Contains(KeyValuePair<string, object?> item)
             {
-                return TryGetValue(item.Key, out object value) && Equals(value, item.Value);
+                return TryGetValue(item.Key, out object? value) && Equals(value, item.Value);
             }
 
-            void ICollection<KeyValuePair<string, object>>.CopyTo(KeyValuePair<string, object>[] array, int arrayIndex)
+            void ICollection<KeyValuePair<string, object?>>.CopyTo(KeyValuePair<string, object?>[] array, int arrayIndex)
             {
                 foreach (var kv in this)
                 {
@@ -124,30 +124,30 @@ IEnumerator IEnumerable.GetEnumerator()
                 }
             }
 
-            bool ICollection<KeyValuePair<string, object>>.Remove(KeyValuePair<string, object> item)
+            bool ICollection<KeyValuePair<string, object?>>.Remove(KeyValuePair<string, object?> item)
             {
-                IDictionary<string, object> dic = this;
+                IDictionary<string, object?> dic = this;
                 return dic.Remove(item.Key);
             }
 
-            bool ICollection<KeyValuePair<string, object>>.IsReadOnly => false;
+            bool ICollection<KeyValuePair<string, object?>>.IsReadOnly => false;
             #endregion
 
             #region Implementation of IDictionary<string,object>
 
-            bool IDictionary<string, object>.ContainsKey(string key)
+            bool IDictionary<string, object?>.ContainsKey(string key)
             {
                 int index = table.IndexOfName(key);
                 if (index < 0 || index >= values.Length || values[index] is DeadValue) return false;
                 return true;
             }
 
-            void IDictionary<string, object>.Add(string key, object value)
+            void IDictionary<string, object?>.Add(string key, object? value)
             {
                 SetValue(key, value, true);
             }
 
-            bool IDictionary<string, object>.Remove(string key)
+            bool IDictionary<string, object?>.Remove(string key)
                 => Remove(table.IndexOfName(key));
 
             internal bool Remove(int index)
@@ -157,20 +157,20 @@ internal bool Remove(int index)
                 return true;
             }
 
-            object IDictionary<string, object>.this[string key]
+            object? IDictionary<string, object?>.this[string key]
             {
-                get { TryGetValue(key, out object val); return val; }
+                get { TryGetValue(key, out object? val); return val; }
                 set { SetValue(key, value, false); }
             }
 
-            public object SetValue(string key, object value)
+            public object? SetValue(string key, object? value)
             {
                 return SetValue(key, value, false);
             }
 
-            private object SetValue(string key, object value, bool isAdd)
+            private object? SetValue(string key, object? value, bool isAdd)
             {
-                if (key == null) throw new ArgumentNullException(nameof(key));
+                if (key is null) throw new ArgumentNullException(nameof(key));
                 int index = table.IndexOfName(key);
                 if (index < 0)
                 {
@@ -183,7 +183,7 @@ private object SetValue(string key, object value, bool isAdd)
                 }
                 return SetValue(index, value);
             }
-            internal object SetValue(int index, object value)
+            internal object? SetValue(int index, object? value)
             {
                 int oldLength = values.Length;
                 if (oldLength <= index)
@@ -199,12 +199,12 @@ internal object SetValue(int index, object value)
                 return values[index] = value;
             }
 
-            ICollection<string> IDictionary<string, object>.Keys
+            ICollection<string> IDictionary<string, object?>.Keys
             {
                 get { return this.Select(kv => kv.Key).ToArray(); }
             }
 
-            ICollection<object> IDictionary<string, object>.Values
+            ICollection<object?> IDictionary<string, object?>.Values
             {
                 get { return this.Select(kv => kv.Value).ToArray(); }
             }
@@ -215,7 +215,7 @@ internal object SetValue(int index, object value)
             #region Implementation of IReadOnlyDictionary<string,object>
 
 
-            int IReadOnlyCollection<KeyValuePair<string, object>>.Count
+            int IReadOnlyCollection<KeyValuePair<string, object?>>.Count
             {
                 get
                 {
@@ -223,23 +223,23 @@ internal object SetValue(int index, object value)
                 }
             }
 
-            bool IReadOnlyDictionary<string, object>.ContainsKey(string key)
+            bool IReadOnlyDictionary<string, object?>.ContainsKey(string key)
             {
                 int index = table.IndexOfName(key);
                 return index >= 0 && index < values.Length && !(values[index] is DeadValue);
             }
 
-            object IReadOnlyDictionary<string, object>.this[string key]
+            object? IReadOnlyDictionary<string, object?>.this[string key]
             {
-                get { TryGetValue(key, out object val); return val; }
+                get { TryGetValue(key, out object? val); return val; }
             }
 
-            IEnumerable<string> IReadOnlyDictionary<string, object>.Keys
+            IEnumerable<string> IReadOnlyDictionary<string, object?>.Keys
             {
                 get { return this.Select(kv => kv.Key); }
             }
 
-            IEnumerable<object> IReadOnlyDictionary<string, object>.Values
+            IEnumerable<object?> IReadOnlyDictionary<string, object?>.Values
             {
                 get { return this.Select(kv => kv.Value); }
             }

Dapper/SqlMapper.DapperRowMetaObject.cs

@@ -16,8 +16,8 @@ private sealed partial class DapperRow : System.Dynamic.IDynamicMetaObjectProvid
 
         private sealed class DapperRowMetaObject : System.Dynamic.DynamicMetaObject
         {
-            private static readonly MethodInfo getValueMethod = typeof(IDictionary<string, object>).GetProperty("Item").GetGetMethod();
-            private static readonly MethodInfo setValueMethod = typeof(DapperRow).GetMethod("SetValue", new Type[] { typeof(string), typeof(object) });
+            private static readonly MethodInfo getValueMethod = typeof(IDictionary<string, object>).GetProperty("Item")!.GetGetMethod()!;
+            private static readonly MethodInfo setValueMethod = typeof(DapperRow).GetMethod("SetValue", new Type[] { typeof(string), typeof(object) })!;
 
             public DapperRowMetaObject(
                 System.Linq.Expressions.Expression expression,

Dapper/SqlMapper.DapperTable.cs

@@ -21,18 +21,18 @@ public DapperTable(string[] fieldNames)
                 for (int i = fieldNames.Length - 1; i >= 0; i--)
                 {
                     string key = fieldNames[i];
-                    if (key != null) fieldNameLookup[key] = i;
+                    if (key is not null) fieldNameLookup[key] = i;
                 }
             }
 
             internal int IndexOfName(string name)
             {
-                return (name != null && fieldNameLookup.TryGetValue(name, out int result)) ? result : -1;
+                return (name is not null && fieldNameLookup.TryGetValue(name, out int result)) ? result : -1;
             }
 
             internal int AddField(string name)
             {
-                if (name == null) throw new ArgumentNullException(nameof(name));
+                if (name is null) throw new ArgumentNullException(nameof(name));
                 if (fieldNameLookup.ContainsKey(name)) throw new InvalidOperationException("Field already exists: " + name);
                 int oldLen = fieldNames.Length;
                 Array.Resize(ref fieldNames, oldLen + 1); // yes, this is sub-optimal, but this is not the expected common case
@@ -41,7 +41,7 @@ internal int AddField(string name)
                 return oldLen;
             }
 
-            internal bool FieldExists(string key) => key != null && fieldNameLookup.ContainsKey(key);
+            internal bool FieldExists(string key) => key is not null && fieldNameLookup.ContainsKey(key);
 
             public int FieldCount => fieldNames.Length;
         }

Dapper/SqlMapper.GridReader.Async.cs

 using System;
 using System.Collections.Generic;
-using System.Data;
 using System.Data.Common;
-using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
@@ -16,13 +14,6 @@ public partial class GridReader
             : IAsyncDisposable
 #endif
         {
-            private readonly CancellationToken cancel;
-            internal GridReader(IDbCommand command, DbDataReader reader, Identity identity, DynamicParameters dynamicParams, bool addToCache, CancellationToken cancel)
-                : this(command, reader, identity, dynamicParams, addToCache)
-            {
-                this.cancel = cancel;
-            }
-
             /// <summary>
             /// Read the next grid of results, returned as a dynamic object
             /// </summary>
@@ -40,7 +31,7 @@ internal GridReader(IDbCommand command, DbDataReader reader, Identity identity,
             /// Read an individual row of the next grid of results, returned as a dynamic object
             /// </summary>
             /// <remarks>Note: the row can be accessed via "dynamic", or by casting to an IDictionary&lt;string,object&gt;</remarks>
-            public Task<dynamic> ReadFirstOrDefaultAsync() => ReadRowAsyncImpl<dynamic>(typeof(DapperRow), Row.FirstOrDefault);
+            public Task<dynamic?> ReadFirstOrDefaultAsync() => ReadRowAsyncImpl<dynamic?>(typeof(DapperRow), Row.FirstOrDefault);
 
             /// <summary>
             /// Read an individual row of the next grid of results, returned as a dynamic object
@@ -52,7 +43,7 @@ internal GridReader(IDbCommand command, DbDataReader reader, Identity identity,
             /// Read an individual row of the next grid of results, returned as a dynamic object
             /// </summary>
             /// <remarks>Note: the row can be accessed via "dynamic", or by casting to an IDictionary&lt;string,object&gt;</remarks>
-            public Task<dynamic> ReadSingleOrDefaultAsync() => ReadRowAsyncImpl<dynamic>(typeof(DapperRow), Row.SingleOrDefault);
+            public Task<dynamic?> ReadSingleOrDefaultAsync() => ReadRowAsyncImpl<dynamic?>(typeof(DapperRow), Row.SingleOrDefault);
 
             /// <summary>
             /// Read the next grid of results
@@ -62,7 +53,7 @@ internal GridReader(IDbCommand command, DbDataReader reader, Identity identity,
             /// <exception cref="ArgumentNullException"><paramref name="type"/> is <c>null</c>.</exception>
             public Task<IEnumerable<object>> ReadAsync(Type type, bool buffered = true)
             {
-                if (type == null) throw new ArgumentNullException(nameof(type));
+                if (type is null) throw new ArgumentNullException(nameof(type));
                 return ReadAsyncImpl<object>(type, buffered);
             }
 
@@ -73,7 +64,7 @@ public Task<IEnumerable<object>> ReadAsync(Type type, bool buffered = true)
             /// <exception cref="ArgumentNullException"><paramref name="type"/> is <c>null</c>.</exception>
             public Task<object> ReadFirstAsync(Type type)
             {
-                if (type == null) throw new ArgumentNullException(nameof(type));
+                if (type is null) throw new ArgumentNullException(nameof(type));
                 return ReadRowAsyncImpl<object>(type, Row.First);
             }
 
@@ -82,10 +73,10 @@ public Task<object> ReadFirstAsync(Type type)
             /// </summary>
             /// <param name="type">The type to read.</param>
             /// <exception cref="ArgumentNullException"><paramref name="type"/> is <c>null</c>.</exception>
-            public Task<object> ReadFirstOrDefaultAsync(Type type)
+            public Task<object?> ReadFirstOrDefaultAsync(Type type)
             {
-                if (type == null) throw new ArgumentNullException(nameof(type));
-                return ReadRowAsyncImpl<object>(type, Row.FirstOrDefault);
+                if (type is null) throw new ArgumentNullException(nameof(type));
+                return ReadRowAsyncImpl<object?>(type, Row.FirstOrDefault);
             }
 
             /// <summary>
@@ -95,7 +86,7 @@ public Task<object> ReadFirstOrDefaultAsync(Type type)
             /// <exception cref="ArgumentNullException"><paramref name="type"/> is <c>null</c>.</exception>
             public Task<object> ReadSingleAsync(Type type)
             {
-                if (type == null) throw new ArgumentNullException(nameof(type));
+                if (type is null) throw new ArgumentNullException(nameof(type));
                 return ReadRowAsyncImpl<object>(type, Row.Single);
             }
 
@@ -104,10 +95,10 @@ public Task<object> ReadSingleAsync(Type type)
             /// </summary>
             /// <param name="type">The type to read.</param>
             /// <exception cref="ArgumentNullException"><paramref name="type"/> is <c>null</c>.</exception>
-            public Task<object> ReadSingleOrDefaultAsync(Type type)
+            public Task<object?> ReadSingleOrDefaultAsync(Type type)
             {
-                if (type == null) throw new ArgumentNullException(nameof(type));
-                return ReadRowAsyncImpl<object>(type, Row.SingleOrDefault);
+                if (type is null) throw new ArgumentNullException(nameof(type));
+                return ReadRowAsyncImpl<object?>(type, Row.SingleOrDefault);
             }
 
             /// <summary>
@@ -127,7 +118,7 @@ public Task<object> ReadSingleOrDefaultAsync(Type type)
             /// Read an individual row of the next grid of results.
             /// </summary>
             /// <typeparam name="T">The type to read.</typeparam>
-            public Task<T> ReadFirstOrDefaultAsync<T>() => ReadRowAsyncImpl<T>(typeof(T), Row.FirstOrDefault);
+            public Task<T?> ReadFirstOrDefaultAsync<T>() => ReadRowAsyncImpl<T?>(typeof(T), Row.FirstOrDefault);
 
             /// <summary>
             /// Read an individual row of the next grid of results.
@@ -139,15 +130,25 @@ public Task<object> ReadSingleOrDefaultAsync(Type type)
             /// Read an individual row of the next grid of results.
             /// </summary>
             /// <typeparam name="T">The type to read.</typeparam>
-            public Task<T> ReadSingleOrDefaultAsync<T>() => ReadRowAsyncImpl<T>(typeof(T), Row.SingleOrDefault);
+            public Task<T?> ReadSingleOrDefaultAsync<T>() => ReadRowAsyncImpl<T?>(typeof(T), Row.SingleOrDefault);
 
-            private async Task NextResultAsync()
+            /// <summary>
+            /// Marks the current grid as consumed, and moves to the next result
+            /// </summary>
+            protected async Task OnAfterGridAsync(int index)
             {
-                if (await reader.NextResultAsync(cancel).ConfigureAwait(false))
+                if (index != ResultIndex)
+                {
+                    // not our data
+                }
+                else if (reader is null)
+                {
+                    // nothing to do
+                }
+                else if (await reader.NextResultAsync(cancel).ConfigureAwait(false))
                 {
                     // readCount++;
-                    gridIndex++;
-                    IsConsumed = false;
+                    _resultIndexAndConsumedFlag = index + 1;
                 }
                 else
                 {
@@ -158,8 +159,8 @@ private async Task NextResultAsync()
 #else
                     reader.Dispose();
 #endif
-                    reader = null;
-                    callbacks?.OnCompleted();
+                    reader = null!;
+                    onCompleted?.Invoke(state);
 #if NET5_0_OR_GREATER
                     await DisposeAsync();
 #else
@@ -170,52 +171,47 @@ private async Task NextResultAsync()
 
             private Task<IEnumerable<T>> ReadAsyncImpl<T>(Type type, bool buffered)
             {
-                var deserializer = ValidateAndMarkConsumed(type);
+                var deserializer = ValidateAndMarkConsumed(type, out var index);
                 if (buffered)
                 {
-                    return ReadBufferedAsync<T>(gridIndex, deserializer);
+                    return ReadBufferedAsync<T>(index, deserializer);
                 }
                 else
                 {
-                    var result = ReadDeferred<T>(gridIndex, deserializer, type);
-                    if (buffered) result = result?.ToList(); // for the "not a DbDataReader" scenario
+                    var result = ReadDeferred<T>(index, deserializer, type);
                     return Task.FromResult(result);
                 }
             }
 
-            private Func<DbDataReader, object> ValidateAndMarkConsumed(Type type)
+            private Func<DbDataReader, object> ValidateAndMarkConsumed(Type type, out int index)
             {
-                if (reader == null) throw new ObjectDisposedException(GetType().FullName, "The reader has been disposed; this can happen after all data has been consumed");
-                if (IsConsumed) throw new InvalidOperationException("Query results must be consumed in the correct order, and each result can only be consumed once");
-                var typedIdentity = identity.ForGrid(type, gridIndex);
+                index = OnBeforeGrid();
+                var typedIdentity = Identity.ForGrid(type, index);
                 CacheInfo cache = GetCacheInfo(typedIdentity, null, addToCache);
                 var deserializer = cache.Deserializer;
 
                 int hash = GetColumnHash(reader);
-                if (deserializer.Func == null || deserializer.Hash != hash)
+                if (deserializer.Func is null || deserializer.Hash != hash)
                 {
                     deserializer = new DeserializerState(hash, GetDeserializer(type, reader, 0, -1, false));
                     cache.Deserializer = deserializer;
                 }
-                IsConsumed = true;
                 return deserializer.Func;
             }
 
             private async Task<T> ReadRowAsyncImpl<T>(Type type, Row row)
             {
-                if (reader == null) throw new ObjectDisposedException(GetType().FullName, "The reader has been disposed; this can happen after all data has been consumed");
-                if (IsConsumed) throw new InvalidOperationException("Query results must be consumed in the correct order, and each result can only be consumed once");
+                var index = OnBeforeGrid();
 
-                IsConsumed = true;
-                T result = default;
+                T result = default!;
                 if (await reader.ReadAsync(cancel).ConfigureAwait(false) && reader.FieldCount != 0)
                 {
-                    var typedIdentity = identity.ForGrid(type, gridIndex);
+                    var typedIdentity = Identity.ForGrid(type, index);
                     CacheInfo cache = GetCacheInfo(typedIdentity, null, addToCache);
                     var deserializer = cache.Deserializer;
 
                     int hash = GetColumnHash(reader);
-                    if (deserializer.Func == null || deserializer.Hash != hash)
+                    if (deserializer.Func is null || deserializer.Hash != hash)
                     {
                         deserializer = new DeserializerState(hash, GetDeserializer(type, reader, 0, -1, false));
                         cache.Deserializer = deserializer;
@@ -230,7 +226,7 @@ private async Task<T> ReadRowAsyncImpl<T>(Type type, Row row)
                 {
                     ThrowZeroRows(row);
                 }
-                await NextResultAsync().ConfigureAwait(false);
+                await OnAfterGridAsync(index).ConfigureAwait(false);
                 return result;
             }
 
@@ -239,7 +235,7 @@ private async Task<IEnumerable<T>> ReadBufferedAsync<T>(int index, Func<DbDataRe
                 try
                 {
                     var buffer = new List<T>();
-                    while (index == gridIndex && await reader.ReadAsync(cancel).ConfigureAwait(false))
+                    while (index == ResultIndex && await reader!.ReadAsync(cancel).ConfigureAwait(false))
                     {
                         buffer.Add(ConvertTo<T>(deserializer(reader)));
                     }
@@ -247,10 +243,7 @@ private async Task<IEnumerable<T>> ReadBufferedAsync<T>(int index, Func<DbDataRe
                 }
                 finally // finally so that First etc progresses things even when multiple rows
                 {
-                    if (index == gridIndex)
-                    {
-                        await NextResultAsync().ConfigureAwait(false);
-                    }
+                    await OnAfterGridAsync(index).ConfigureAwait(false);
                 }
             }
 
@@ -261,27 +254,29 @@ private async Task<IEnumerable<T>> ReadBufferedAsync<T>(int index, Func<DbDataRe
             /// <typeparam name="T">The type to read.</typeparam>
             public IAsyncEnumerable<T> ReadUnbufferedAsync<T>() => ReadAsyncUnbufferedImpl<T>(typeof(T));
 
+            /// <summary>
+            /// Read the next grid of results.
+            /// </summary>
+            public IAsyncEnumerable<dynamic> ReadUnbufferedAsync() => ReadAsyncUnbufferedImpl<dynamic>(typeof(DapperRow));
+
             private IAsyncEnumerable<T> ReadAsyncUnbufferedImpl<T>(Type type)
             {
-                var deserializer = ValidateAndMarkConsumed(type);
-                return ReadUnbufferedAsync<T>(gridIndex, deserializer, cancel);
+                var deserializer = ValidateAndMarkConsumed(type, out var index);
+                return ReadUnbufferedAsync<T>(index, deserializer, cancel);
             }
 
             private async IAsyncEnumerable<T> ReadUnbufferedAsync<T>(int index, Func<DbDataReader, object> deserializer, [EnumeratorCancellation] CancellationToken cancel)
             {
                 try
                 {
-                    while (index == gridIndex && await reader.ReadAsync(cancel).ConfigureAwait(false))
+                    while (index == ResultIndex && await reader!.ReadAsync(cancel).ConfigureAwait(false))
                     {
                         yield return ConvertTo<T>(deserializer(reader));
                     }
                 }
                 finally // finally so that First etc progresses things even when multiple rows
                 {
-                    if (index == gridIndex)
-                    {
-                        await NextResultAsync().ConfigureAwait(false);
-                    }
+                    await OnAfterGridAsync(index).ConfigureAwait(false);
                 }
             }
 
@@ -290,13 +285,13 @@ private async IAsyncEnumerable<T> ReadUnbufferedAsync<T>(int index, Func<DbDataR
             /// </summary>
             public async ValueTask DisposeAsync()
             {
-                if (reader != null)
+                if (reader is not null)
                 {
                     if (!reader.IsClosed) Command?.Cancel();
                     await reader.DisposeAsync();
-                    reader = null;
+                    reader = null!;
                 }
-                if (Command != null)
+                if (Command is not null)
                 {
                     if (Command is DbCommand typed)
                     {
@@ -306,7 +301,7 @@ public async ValueTask DisposeAsync()
                     {
                         Command.Dispose();
                     }
-                    Command = null;
+                    Command = null!;
                 }
                 GC.SuppressFinalize(this);
             }

Dapper/SqlMapper.GridReader.cs

 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Data;
 using System.Data.Common;
 using System.Globalization;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using System.Threading;
 
 namespace Dapper
 {
@@ -16,16 +18,43 @@ public static partial class SqlMapper
         public partial class GridReader : IDisposable
         {
             private DbDataReader reader;
-            private readonly Identity identity;
+            private Identity? _identity;
             private readonly bool addToCache;
+            private readonly Action<object?>? onCompleted;
+            private readonly object? state;
+            private readonly CancellationToken cancel;
 
-            internal GridReader(IDbCommand command, DbDataReader reader, Identity identity, IParameterCallbacks callbacks, bool addToCache)
+            /// <summary>
+            /// Creates a grid reader over an existing command and reader
+            /// </summary>
+            [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+            protected GridReader(IDbCommand command, DbDataReader reader, Identity? identity, Action<object?>? onCompleted = null, object? state = null, bool addToCache = false, CancellationToken cancellationToken = default)
             {
                 Command = command;
                 this.reader = reader;
-                this.identity = identity;
-                this.callbacks = callbacks;
+                _identity = identity;
+                this.onCompleted = onCompleted;
+                this.state = state;
                 this.addToCache = addToCache;
+                cancel = cancellationToken;
+            }
+
+            internal GridReader(IDbCommand command, DbDataReader reader, Identity identity, IParameterCallbacks? callbacks, bool addToCache,
+                CancellationToken cancellationToken = default)
+                : this(command, reader, identity, callbacks is null ? null : static state => ((IParameterCallbacks)state!).OnCompleted(),
+                      callbacks, addToCache, cancellationToken)
+            { }
+
+            private Identity Identity => _identity ??= CreateIdentity();
+
+            private Identity CreateIdentity()
+            {
+                var cmd = Command;
+                if (cmd is not null && cmd.Connection is not null)
+                {
+                    return new Identity(cmd.CommandText, cmd.CommandType, cmd.Connection, null, null);
+                }
+                throw new InvalidOperationException("This operation requires an identity or a connected command");
             }
 
             /// <summary>
@@ -45,7 +74,7 @@ internal GridReader(IDbCommand command, DbDataReader reader, Identity identity,
             /// Read an individual row of the next grid of results, returned as a dynamic object.
             /// </summary>
             /// <remarks>Note: the row can be accessed via "dynamic", or by casting to an IDictionary&lt;string,object&gt;</remarks>
-            public dynamic ReadFirstOrDefault() => ReadRow<dynamic>(typeof(DapperRow), Row.FirstOrDefault);
+            public dynamic? ReadFirstOrDefault() => ReadRow<dynamic>(typeof(DapperRow), Row.FirstOrDefault);
 
             /// <summary>
             /// Read an individual row of the next grid of results, returned as a dynamic object.
@@ -57,7 +86,7 @@ internal GridReader(IDbCommand command, DbDataReader reader, Identity identity,
             /// Read an individual row of the next grid of results, returned as a dynamic object.
             /// </summary>
             /// <remarks>Note: the row can be accessed via "dynamic", or by casting to an IDictionary&lt;string,object&gt;</remarks>
-            public dynamic ReadSingleOrDefault() => ReadRow<dynamic>(typeof(DapperRow), Row.SingleOrDefault);
+            public dynamic? ReadSingleOrDefault() => ReadRow<dynamic>(typeof(DapperRow), Row.SingleOrDefault);
 
             /// <summary>
             /// Read the next grid of results.
@@ -76,7 +105,7 @@ internal GridReader(IDbCommand command, DbDataReader reader, Identity identity,
             /// Read an individual row of the next grid of results.
             /// </summary>
             /// <typeparam name="T">The type to read.</typeparam>
-            public T ReadFirstOrDefault<T>() => ReadRow<T>(typeof(T), Row.FirstOrDefault);
+            public T? ReadFirstOrDefault<T>() => ReadRow<T>(typeof(T), Row.FirstOrDefault);
 
             /// <summary>
             /// Read an individual row of the next grid of results.
@@ -88,7 +117,7 @@ internal GridReader(IDbCommand command, DbDataReader reader, Identity identity,
             /// Read an individual row of the next grid of results.
             /// </summary>
             /// <typeparam name="T">The type to read.</typeparam>
-            public T ReadSingleOrDefault<T>() => ReadRow<T>(typeof(T), Row.SingleOrDefault);
+            public T? ReadSingleOrDefault<T>() => ReadRow<T>(typeof(T), Row.SingleOrDefault);
 
             /// <summary>
             /// Read the next grid of results.
@@ -98,7 +127,7 @@ internal GridReader(IDbCommand command, DbDataReader reader, Identity identity,
             /// <exception cref="ArgumentNullException"><paramref name="type"/> is <c>null</c>.</exception>
             public IEnumerable<object> Read(Type type, bool buffered = true)
             {
-                if (type == null) throw new ArgumentNullException(nameof(type));
+                if (type is null) throw new ArgumentNullException(nameof(type));
                 return ReadImpl<object>(type, buffered);
             }
 
@@ -109,7 +138,7 @@ public IEnumerable<object> Read(Type type, bool buffered = true)
             /// <exception cref="ArgumentNullException"><paramref name="type"/> is <c>null</c>.</exception>
             public object ReadFirst(Type type)
             {
-                if (type == null) throw new ArgumentNullException(nameof(type));
+                if (type is null) throw new ArgumentNullException(nameof(type));
                 return ReadRow<object>(type, Row.First);
             }
 
@@ -118,9 +147,9 @@ public object ReadFirst(Type type)
             /// </summary>
             /// <param name="type">The type to read.</param>
             /// <exception cref="ArgumentNullException"><paramref name="type"/> is <c>null</c>.</exception>
-            public object ReadFirstOrDefault(Type type)
+            public object? ReadFirstOrDefault(Type type)
             {
-                if (type == null) throw new ArgumentNullException(nameof(type));
+                if (type is null) throw new ArgumentNullException(nameof(type));
                 return ReadRow<object>(type, Row.FirstOrDefault);
             }
 
@@ -131,7 +160,7 @@ public object ReadFirstOrDefault(Type type)
             /// <exception cref="ArgumentNullException"><paramref name="type"/> is <c>null</c>.</exception>
             public object ReadSingle(Type type)
             {
-                if (type == null) throw new ArgumentNullException(nameof(type));
+                if (type is null) throw new ArgumentNullException(nameof(type));
                 return ReadRow<object>(type, Row.Single);
             }
 
@@ -140,46 +169,55 @@ public object ReadSingle(Type type)
             /// </summary>
             /// <param name="type">The type to read.</param>
             /// <exception cref="ArgumentNullException"><paramref name="type"/> is <c>null</c>.</exception>
-            public object ReadSingleOrDefault(Type type)
+            public object? ReadSingleOrDefault(Type type)
             {
-                if (type == null) throw new ArgumentNullException(nameof(type));
+                if (type is null) throw new ArgumentNullException(nameof(type));
                 return ReadRow<object>(type, Row.SingleOrDefault);
             }
 
-            private IEnumerable<T> ReadImpl<T>(Type type, bool buffered)
+
+            /// <summary>
+            /// Validates that data is available, returning the <see cref="ResultIndex"/> that corresponds to the current grid - and marks the current grid as consumed;
+            /// this call <em>must</em> be paired with a call to <see cref="OnAfterGrid(int)"/> or <see cref="OnAfterGridAsync(int)"/>
+            /// </summary>
+            protected int OnBeforeGrid()
             {
-                if (reader == null) throw new ObjectDisposedException(GetType().FullName, "The reader has been disposed; this can happen after all data has been consumed");
+                if (reader is null) throw new ObjectDisposedException(GetType().FullName, "The reader has been disposed; this can happen after all data has been consumed");
                 if (IsConsumed) throw new InvalidOperationException("Query results must be consumed in the correct order, and each result can only be consumed once");
-                var typedIdentity = identity.ForGrid(type, gridIndex);
+                _resultIndexAndConsumedFlag |= CONSUMED_FLAG;
+                return ResultIndex;
+            }
+
+            private IEnumerable<T> ReadImpl<T>(Type type, bool buffered)
+            {
+                var index = OnBeforeGrid();
+                var typedIdentity = Identity.ForGrid(type, index);
                 CacheInfo cache = GetCacheInfo(typedIdentity, null, addToCache);
                 var deserializer = cache.Deserializer;
 
                 int hash = GetColumnHash(reader);
-                if (deserializer.Func == null || deserializer.Hash != hash)
+                if (deserializer.Func is null || deserializer.Hash != hash)
                 {
                     deserializer = new DeserializerState(hash, GetDeserializer(type, reader, 0, -1, false));
                     cache.Deserializer = deserializer;
                 }
-                IsConsumed = true;
-                var result = ReadDeferred<T>(gridIndex, deserializer.Func, type);
-                return buffered ? result?.ToList() : result;
+                var result = ReadDeferred<T>(index, deserializer.Func, type);
+                return buffered ? result.ToList() : result;
             }
 
             private T ReadRow<T>(Type type, Row row)
             {
-                if (reader == null) throw new ObjectDisposedException(GetType().FullName, "The reader has been disposed; this can happen after all data has been consumed");
-                if (IsConsumed) throw new InvalidOperationException("Query results must be consumed in the correct order, and each result can only be consumed once");
-                IsConsumed = true;
+                var index = OnBeforeGrid();
 
-                T result = default;
+                T result = default!;
                 if (reader.Read() && reader.FieldCount != 0)
                 {
-                    var typedIdentity = identity.ForGrid(type, gridIndex);
+                    var typedIdentity = Identity.ForGrid(type, index);
                     CacheInfo cache = GetCacheInfo(typedIdentity, null, addToCache);
                     var deserializer = cache.Deserializer;
 
                     int hash = GetColumnHash(reader);
-                    if (deserializer.Func == null || deserializer.Hash != hash)
+                    if (deserializer.Func is null || deserializer.Hash != hash)
                     {
                         deserializer = new DeserializerState(hash, GetDeserializer(type, reader, 0, -1, false));
                         cache.Deserializer = deserializer;
@@ -194,15 +232,14 @@ private T ReadRow<T>(Type type, Row row)
                 {
                     ThrowZeroRows(row);
                 }
-                NextResult();
+                OnAfterGrid(index);
                 return result;
             }
 
             private IEnumerable<TReturn> MultiReadInternal<TFirst, TSecond, TThird, TFourth, TFifth, TSixth, TSeventh, TReturn>(Delegate func, string splitOn)
             {
-                var identity = this.identity.ForGrid<TFirst, TSecond, TThird, TFourth, TFifth, TSixth, TSeventh>(typeof(TReturn), gridIndex);
-
-                IsConsumed = true;
+                var index = OnBeforeGrid();
+                var identity = Identity.ForGrid<TFirst, TSecond, TThird, TFourth, TFifth, TSixth, TSeventh>(typeof(TReturn), index);
 
                 try
                 {
@@ -213,13 +250,14 @@ private T ReadRow<T>(Type type, Row row)
                 }
                 finally
                 {
-                    NextResult();
+                    OnAfterGrid(index);
                 }
             }
 
             private IEnumerable<TReturn> MultiReadInternal<TReturn>(Type[] types, Func<object[], TReturn> map, string splitOn)
             {
-                var identity = this.identity.ForGrid(typeof(TReturn), types, gridIndex);
+                var index = OnBeforeGrid();
+                var identity = Identity.ForGrid(typeof(TReturn), types, index);
                 try
                 {
                     foreach (var r in MultiMapImpl<TReturn>(null, default, types, map, splitOn, reader, identity, false))
@@ -229,7 +267,7 @@ private IEnumerable<TReturn> MultiReadInternal<TReturn>(Type[] types, Func<objec
                 }
                 finally
                 {
-                    NextResult();
+                    OnAfterGrid(index);
                 }
             }
 
@@ -356,48 +394,71 @@ private IEnumerable<T> ReadDeferred<T>(int index, Func<DbDataReader, object> des
             {
                 try
                 {
-                    while (index == gridIndex && reader.Read())
+                    while (index == ResultIndex && reader?.Read() == true)
                     {
                         yield return ConvertTo<T>(deserializer(reader));
                     }
                 }
                 finally // finally so that First etc progresses things even when multiple rows
                 {
-                    if (index == gridIndex)
-                    {
-                        NextResult();
-                    }
+                    OnAfterGrid(index);
                 }
             }
 
-            private int gridIndex; //, readCount;
-            private readonly IParameterCallbacks callbacks;
+            const int CONSUMED_FLAG = 1 << 31;
+            private int _resultIndexAndConsumedFlag; //, readCount;
+
+            /// <summary>
+            /// Indicates the current result index
+            /// </summary>
+            protected int ResultIndex => _resultIndexAndConsumedFlag & ~CONSUMED_FLAG;
 
             /// <summary>
             /// Has the underlying reader been consumed?
             /// </summary>
-            public bool IsConsumed { get; private set; }
+            /// <remarks>This also reports <c>true</c> if the current grid is actively being consumed</remarks>
+            public bool IsConsumed => (_resultIndexAndConsumedFlag & CONSUMED_FLAG) != 0;
 
             /// <summary>
             /// The command associated with the reader
             /// </summary>
             public IDbCommand Command { get; set; }
 
-            private void NextResult()
+            /// <summary>
+            /// The underlying reader
+            /// </summary>
+            protected DbDataReader Reader => reader;
+
+            /// <summary>
+            /// The cancellation token associated with this reader
+            /// </summary>
+            protected CancellationToken CancellationToken => cancel;
+
+            /// <summary>
+            /// Marks the current grid as consumed, and moves to the next result
+            /// </summary>
+            protected void OnAfterGrid(int index)
             {
-                if (reader.NextResult())
+                if (index != ResultIndex)
+                {
+                    // not our data!
+                }
+                else if (reader is null)
+                {
+                    // nothing to do
+                }
+                else if (reader.NextResult())
                 {
                     // readCount++;
-                    gridIndex++;
-                    IsConsumed = false;
+                    _resultIndexAndConsumedFlag = index + 1;
                 }
                 else
                 {
                     // happy path; close the reader cleanly - no
                     // need for "Cancel" etc
                     reader.Dispose();
-                    reader = null;
-                    callbacks?.OnCompleted();
+                    reader = null!;
+                    onCompleted?.Invoke(state);
                     Dispose();
                 }
             }
@@ -407,25 +468,25 @@ private void NextResult()
             /// </summary>
             public void Dispose()
             {
-                if (reader != null)
+                if (reader is not null)
                 {
                     if (!reader.IsClosed) Command?.Cancel();
                     reader.Dispose();
-                    reader = null;
+                    reader = null!;
                 }
-                if (Command != null)
+                if (Command is not null)
                 {
                     Command.Dispose();
-                    Command = null;
+                    Command = null!;
                 }
                 GC.SuppressFinalize(this);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            private static T ConvertTo<T>(object value) => value switch
+            private static T ConvertTo<T>(object? value) => value switch
             {
                 T typed => typed,
-                null or DBNull => default,
+                null or DBNull => default!,
                 _ => (T)Convert.ChangeType(value, Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T), CultureInfo.InvariantCulture),
             };
         }

Dapper/SqlMapper.IDataReader.cs

@@ -23,9 +23,9 @@ public static IEnumerable<T> Parse<T>(this IDataReader reader)
                 do
                 {
                     object val = deser(dbReader);
-                    if (val == null || val is T)
+                    if (val is null || val is T)
                     {
-                        yield return (T)val;
+                        yield return (T)val!;
                     }
                     else
                     {
@@ -83,6 +83,7 @@ public static IEnumerable<dynamic> Parse(this IDataReader reader)
 #if DEBUG // make sure we're not using this internally
         [Obsolete(nameof(DbDataReader) + " API should be preferred")]
 #endif
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0026:Do not add multiple public overloads with optional parameters", Justification = "Grandfathered")]
         public static Func<IDataReader, object> GetRowParser(this IDataReader reader, Type type,
             int startIndex = 0, int length = -1, bool returnNullIfFirstMissing = false)
         {
@@ -109,7 +110,8 @@ public static IEnumerable<dynamic> Parse(this IDataReader reader)
 #if DEBUG // make sure we're not using this internally
         [Obsolete(nameof(DbDataReader) + " API should be preferred")]
 #endif
-        public static Func<IDataReader, T> GetRowParser<T>(this IDataReader reader, Type concreteType = null,
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0026:Do not add multiple public overloads with optional parameters", Justification = "Grandfathered")]
+        public static Func<IDataReader, T> GetRowParser<T>(this IDataReader reader, Type? concreteType = null,
             int startIndex = 0, int length = -1, bool returnNullIfFirstMissing = false)
         {
             concreteType ??= typeof(T);
@@ -174,7 +176,7 @@ public static IEnumerable<dynamic> Parse(this IDataReader reader)
         ///     public override int Type =&gt; 2;
         /// }
         /// </example>
-        public static Func<DbDataReader, T> GetRowParser<T>(this DbDataReader reader, Type concreteType = null,
+        public static Func<DbDataReader, T> GetRowParser<T>(this DbDataReader reader, Type? concreteType = null,
             int startIndex = 0, int length = -1, bool returnNullIfFirstMissing = false)
         {
             concreteType ??= typeof(T);

Dapper/SqlMapper.IMemberMap.cs

@@ -23,17 +23,17 @@ public interface IMemberMap
             /// <summary>
             /// Target property
             /// </summary>
-            PropertyInfo Property { get; }
+            PropertyInfo? Property { get; }
 
             /// <summary>
             /// Target field
             /// </summary>
-            FieldInfo Field { get; }
+            FieldInfo? Field { get; }
 
             /// <summary>
             /// Target constructor parameter
             /// </summary>
-            ParameterInfo Parameter { get; }
+            ParameterInfo? Parameter { get; }
         }
     }
 }

Dapper/SqlMapper.IParameterLookup.cs

@@ -11,7 +11,7 @@ public interface IParameterLookup : IDynamicParameters
             /// Get the value of the specified parameter (return null if not found)
             /// </summary>
             /// <param name="name">The name of the parameter to get.</param>
-            object this[string name] { get; }
+            object? this[string name] { get; }
         }
     }
 }

Dapper/SqlMapper.ITypeHandler.cs

@@ -23,7 +23,7 @@ public interface ITypeHandler
             /// <param name="value">The value from the database</param>
             /// <param name="destinationType">The type to parse to</param>
             /// <returns>The typed value</returns>
-            object Parse(Type destinationType, object value);
+            object? Parse(Type destinationType, object value);
         }
     }
 }

Dapper/SqlMapper.ITypeMap.cs

@@ -16,7 +16,7 @@ public interface ITypeMap
             /// <param name="names">DataReader column names</param>
             /// <param name="types">DataReader column types</param>
             /// <returns>Matching constructor or default one</returns>
-            ConstructorInfo FindConstructor(string[] names, Type[] types);
+            ConstructorInfo? FindConstructor(string[] names, Type[] types);
 
             /// <summary>
             /// Returns a constructor which should *always* be used.
@@ -25,7 +25,7 @@ public interface ITypeMap
             /// 
             /// Use this class to force object creation away from parameterless constructors you don't control.
             /// </summary>
-            ConstructorInfo FindExplicitConstructor();
+            ConstructorInfo? FindExplicitConstructor();
 
             /// <summary>
             /// Gets mapping for constructor parameter
@@ -40,7 +40,7 @@ public interface ITypeMap
             /// </summary>
             /// <param name="columnName">DataReader column name</param>
             /// <returns>Mapping implementation</returns>
-            IMemberMap GetMember(string columnName);
+            IMemberMap? GetMember(string columnName);
         }
     }
 }

Dapper/SqlMapper.Identity.cs

@@ -11,10 +11,10 @@ internal sealed class Identity<TFirst, TSecond, TThird, TFourth, TFifth, TSixth,
             private static readonly int s_typeHash;
             private static readonly int s_typeCount = CountNonTrivial(out s_typeHash);
 
-            internal Identity(string sql, CommandType? commandType, string connectionString, Type type, Type parametersType, int gridIndex = 0)
+            internal Identity(string sql, CommandType? commandType, string connectionString, Type type, Type? parametersType, int gridIndex = 0)
                 : base(sql, commandType, connectionString, type, parametersType, s_typeHash, gridIndex)
             {}
-            internal Identity(string sql, CommandType? commandType, IDbConnection connection, Type type, Type parametersType, int gridIndex = 0)
+            internal Identity(string sql, CommandType? commandType, IDbConnection connection, Type type, Type? parametersType, int gridIndex = 0)
                 : base(sql, commandType, connection.ConnectionString, type, parametersType, s_typeHash, gridIndex)
             { }
 
@@ -54,12 +54,12 @@ internal sealed class IdentityWithTypes : Identity
         {
             private readonly Type[] _types;
 
-            internal IdentityWithTypes(string sql, CommandType? commandType, string connectionString, Type type, Type parametersType, Type[] otherTypes, int gridIndex = 0)
+            internal IdentityWithTypes(string sql, CommandType? commandType, string connectionString, Type type, Type? parametersType, Type[] otherTypes, int gridIndex = 0)
                 : base(sql, commandType, connectionString, type, parametersType, HashTypes(otherTypes), gridIndex)
             {
                 _types = otherTypes ?? Type.EmptyTypes;
             }
-            internal IdentityWithTypes(string sql, CommandType? commandType, IDbConnection connection, Type type, Type parametersType, Type[] otherTypes, int gridIndex = 0)
+            internal IdentityWithTypes(string sql, CommandType? commandType, IDbConnection connection, Type type, Type? parametersType, Type[] otherTypes, int gridIndex = 0)
                 : base(sql, commandType, connection.ConnectionString, type, parametersType, HashTypes(otherTypes), gridIndex)
             {
                 _types = otherTypes ?? Type.EmptyTypes;
@@ -72,7 +72,7 @@ internal IdentityWithTypes(string sql, CommandType? commandType, IDbConnection c
             static int HashTypes(Type[] types)
             {
                 var hashCode = 0;
-                if (types != null)
+                if (types is not null)
                 {
                     foreach (var t in types)
                     {
@@ -99,7 +99,7 @@ public class Identity : IEquatable<Identity>
                 new Identity(sql, commandType, connectionString, primaryType, parametersType, 0, gridIndex);
 
             internal Identity ForGrid(Type primaryType, Type[] otherTypes, int gridIndex) =>
-                (otherTypes == null || otherTypes.Length == 0)
+                (otherTypes is null || otherTypes.Length == 0)
                 ? new Identity(sql, commandType, connectionString, primaryType, parametersType, 0, gridIndex)
                 : new IdentityWithTypes(sql, commandType, connectionString, primaryType, parametersType, otherTypes, gridIndex);
 
@@ -111,10 +111,10 @@ public class Identity : IEquatable<Identity>
             public Identity ForDynamicParameters(Type type) =>
                 new Identity(sql, commandType, connectionString, this.type, type, 0, -1);
 
-            internal Identity(string sql, CommandType? commandType, IDbConnection connection, Type type, Type parametersType)
+            internal Identity(string sql, CommandType? commandType, IDbConnection connection, Type? type, Type? parametersType)
                 : this(sql, commandType, connection.ConnectionString, type, parametersType, 0, 0) { /* base call */ }
 
-            private protected Identity(string sql, CommandType? commandType, string connectionString, Type type, Type parametersType, int otherTypesHash, int gridIndex)
+            private protected Identity(string sql, CommandType? commandType, string connectionString, Type? type, Type? parametersType, int otherTypesHash, int gridIndex)
             {
                 this.sql = sql;
                 this.commandType = commandType;
@@ -130,7 +130,7 @@ private protected Identity(string sql, CommandType? commandType, string connecti
                     hashCode = (hashCode * 23) + (sql?.GetHashCode() ?? 0);
                     hashCode = (hashCode * 23) + (type?.GetHashCode() ?? 0);
                     hashCode = (hashCode * 23) + otherTypesHash;
-                    hashCode = (hashCode * 23) + (connectionString == null ? 0 : connectionStringComparer.GetHashCode(connectionString));
+                    hashCode = (hashCode * 23) + (connectionString is null ? 0 : connectionStringComparer.GetHashCode(connectionString));
                     hashCode = (hashCode * 23) + (parametersType?.GetHashCode() ?? 0);
                 }
             }
@@ -139,7 +139,7 @@ private protected Identity(string sql, CommandType? commandType, string connecti
             /// Whether this <see cref="Identity"/> equals another.
             /// </summary>
             /// <param name="obj">The other <see cref="object"/> to compare to.</param>
-            public override bool Equals(object obj) => Equals(obj as Identity);
+            public override bool Equals(object? obj) => Equals(obj as Identity);
 
             /// <summary>
             /// The raw SQL command.
@@ -164,7 +164,7 @@ private protected Identity(string sql, CommandType? commandType, string connecti
             /// <summary>
             /// This <see cref="Type"/> of this Identity.
             /// </summary>
-            public readonly Type type;
+            public readonly Type? type;
 
             /// <summary>
             /// The connection string for this Identity.
@@ -174,7 +174,7 @@ private protected Identity(string sql, CommandType? commandType, string connecti
             /// <summary>
             /// The type of the parameters object for this Identity.
             /// </summary>
-            public readonly Type parametersType;
+            public readonly Type? parametersType;
 
             /// <summary>
             /// Gets the hash code for this identity.
@@ -192,7 +192,7 @@ private protected Identity(string sql, CommandType? commandType, string connecti
             /// </summary>
             /// <param name="other">The other <see cref="Identity"/> object to compare.</param>
             /// <returns>Whether the two are equal</returns>
-            public bool Equals(Identity other)
+            public bool Equals(Identity? other)
             {
                 if (ReferenceEquals(this, other)) return true;
                 if (other is null) return false;

Dapper/SqlMapper.Link.cs

-using System.Threading;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading;
 
 namespace Dapper
 {
@@ -13,13 +14,14 @@ public static partial class SqlMapper
         /// <typeparam name="TValue">The value type of the cache.</typeparam>
         internal class Link<TKey, TValue> where TKey : class
         {
-            public static bool TryGet(Link<TKey, TValue> link, TKey key, out TValue value)
+            public static void Clear(ref Link<TKey, TValue>? head) => Interlocked.Exchange(ref head, null);
+            public static bool TryGet(Link<TKey, TValue>? link, TKey key, [NotNullWhen(true)] out TValue? value)
             {
-                while (link != null)
+                while (link is not null)
                 {
                     if ((object)key == (object)link.Key)
                     {
-                        value = link.Value;
+                        value = link.Value!;
                         return true;
                     }
                     link = link.Tail;
@@ -28,13 +30,13 @@ public static bool TryGet(Link<TKey, TValue> link, TKey key, out TValue value)
                 return false;
             }
 
-            public static bool TryAdd(ref Link<TKey, TValue> head, TKey key, ref TValue value)
+            public static bool TryAdd(ref Link<TKey, TValue>? head, TKey key, ref TValue value)
             {
                 bool tryAgain;
                 do
                 {
                     var snapshot = Interlocked.CompareExchange(ref head, null, null);
-                    if (TryGet(snapshot, key, out TValue found))
+                    if (TryGet(snapshot, key, out TValue? found))
                     { // existing match; report the existing value instead
                         value = found;
                         return false;
@@ -46,7 +48,7 @@ public static bool TryAdd(ref Link<TKey, TValue> head, TKey key, ref TValue valu
                 return true;
             }
 
-            private Link(TKey key, TValue value, Link<TKey, TValue> tail)
+            private Link(TKey key, TValue value, Link<TKey, TValue>? tail)
             {
                 Key = key;
                 Value = value;
@@ -55,7 +57,7 @@ private Link(TKey key, TValue value, Link<TKey, TValue> tail)
 
             public TKey Key { get; }
             public TValue Value { get; }
-            public Link<TKey, TValue> Tail { get; }
+            public Link<TKey, TValue>? Tail { get; }
         }
     }
 }

Dapper/SqlMapper.Settings.cs

 using System;
 using System.Data;
+using System.Threading;
 
 namespace Dapper
 {
@@ -63,7 +64,9 @@ static Settings()
             public static void SetDefaults()
             {
                 CommandTimeout = null;
-                ApplyNullValues = false;
+                ApplyNullValues = PadListExpansions = UseIncrementalPseudoPositionalParameterNames = false;
+                AllowedCommandBehaviors = DefaultAllowedCommandBehaviors;
+                FetchSize = InListStringSplitCount = -1;
             }
 
             /// <summary>
@@ -99,6 +102,26 @@ public static void SetDefaults()
             /// instead of the original name; for most scenarios, this is ignored since the name is redundant, but "snowflake" requires this.
             /// </summary>
             public static bool UseIncrementalPseudoPositionalParameterNames { get; set; }
+
+            /// <summary>
+            /// If assigned a non-negative value, then that value is applied to any commands <c>FetchSize</c> property, if it exists;
+            /// see https://docs.oracle.com/en/database/oracle/oracle-database/18/odpnt/CommandFetchSize.html; note that this value
+            /// can only be set globally - it is not intended for frequent/contextual changing.
+            /// </summary>
+            public static long FetchSize
+            {
+                get => Volatile.Read(ref s_FetchSize);
+                set
+                {
+                    if (Volatile.Read(ref s_FetchSize) != value)
+                    {
+                        Volatile.Write(ref s_FetchSize, value);
+                        CommandDefinition.ResetCommandInitCache(); // if this setting is useful: we've invalidated things
+                    }
+                }
+            }
+
+            private static long s_FetchSize = -1;
         }
     }
 }

Dapper/SqlMapper.TypeDeserializerCache.cs

@@ -35,13 +35,13 @@ internal static void Purge()
 
             internal static Func<DbDataReader, object> GetReader(Type type, DbDataReader reader, int startBound, int length, bool returnNullIfFirstMissing)
             {
-                var found = (TypeDeserializerCache)byType[type];
-                if (found == null)
+                var found = (TypeDeserializerCache?)byType[type];
+                if (found is null)
                 {
                     lock (byType)
                     {
-                        found = (TypeDeserializerCache)byType[type];
-                        if (found == null)
+                        found = (TypeDeserializerCache?)byType[type];
+                        if (found is null)
                         {
                             byType[type] = found = new TypeDeserializerCache(type);
                         }
@@ -56,9 +56,9 @@ internal static void Purge()
             {
                 private readonly int startBound, length;
                 private readonly bool returnNullIfFirstMissing;
-                private readonly DbDataReader reader;
-                private readonly string[] names;
-                private readonly Type[] types;
+                private readonly DbDataReader? reader;
+                private readonly string[]? names;
+                private readonly Type[]? types;
                 private readonly int hashCode;
 
                 public DeserializerKey(int hashCode, int startBound, int length, bool returnNullIfFirstMissing, DbDataReader reader, bool copyDown)
@@ -92,11 +92,11 @@ public DeserializerKey(int hashCode, int startBound, int length, bool returnNull
 
                 public override string ToString()
                 { // only used in the debugger
-                    if (names != null)
+                    if (names is not null)
                     {
                         return string.Join(", ", names);
                     }
-                    if (reader != null)
+                    if (reader is not null)
                     {
                         var sb = new StringBuilder();
                         int index = startBound;
@@ -107,10 +107,10 @@ public override string ToString()
                         }
                         return sb.ToString();
                     }
-                    return base.ToString();
+                    return base.ToString() ?? "";
                 }
 
-                public override bool Equals(object obj)
+                public override bool Equals(object? obj)
                     => obj is DeserializerKey key && Equals(key);
 
                 public bool Equals(DeserializerKey other)
@@ -143,10 +143,10 @@ public bool Equals(DeserializerKey other)
                 if (returnNullIfFirstMissing) hash *= -27;
                 // get a cheap key first: false means don't copy the values down
                 var key = new DeserializerKey(hash, startBound, length, returnNullIfFirstMissing, reader, false);
-                Func<DbDataReader, object> deser;
+                Func<DbDataReader, object>? deser;
                 lock (readers)
                 {
-                    if (readers.TryGetValue(key, out deser)) return deser;
+                    if (readers.TryGetValue(key, out deser)) return deser!;
                 }
                 deser = GetTypeDeserializerImpl(type, reader, startBound, length, returnNullIfFirstMissing);
                 // get a more expensive key: true means copy the values down so it can be used as a key later

Dapper/SqlMapper.TypeHandler.cs

@@ -16,14 +16,14 @@ public abstract class TypeHandler<T> : ITypeHandler
             /// </summary>
             /// <param name="parameter">The parameter to configure</param>
             /// <param name="value">Parameter value</param>
-            public abstract void SetValue(IDbDataParameter parameter, T value);
+            public abstract void SetValue(IDbDataParameter parameter, T? value);
 
             /// <summary>
             /// Parse a database value back to a typed value
             /// </summary>
             /// <param name="value">The value from the database</param>
             /// <returns>The typed value</returns>
-            public abstract T Parse(object value);
+            public abstract T? Parse(object value);
 
             void ITypeHandler.SetValue(IDbDataParameter parameter, object value)
             {
@@ -33,11 +33,11 @@ void ITypeHandler.SetValue(IDbDataParameter parameter, object value)
                 }
                 else
                 {
-                    SetValue(parameter, (T)value);
+                    SetValue(parameter, (T?)value);
                 }
             }
 
-            object ITypeHandler.Parse(Type destinationType, object value)
+            object? ITypeHandler.Parse(Type destinationType, object value)
             {
                 return Parse(value);
             }
@@ -66,9 +66,9 @@ public abstract class StringTypeHandler<T> : TypeHandler<T>
             /// </summary>
             /// <param name="parameter">The parameter to configure</param>
             /// <param name="value">Parameter value</param>
-            public override void SetValue(IDbDataParameter parameter, T value)
+            public override void SetValue(IDbDataParameter parameter, T? value)
             {
-                parameter.Value = value == null ? (object)DBNull.Value : Format(value);
+                parameter.Value = value is null ? (object)DBNull.Value : Format(value);
             }
 
             /// <summary>
@@ -78,7 +78,7 @@ public override void SetValue(IDbDataParameter parameter, T value)
             /// <returns>The typed value</returns>
             public override T Parse(object value)
             {
-                if (value == null || value is DBNull) return default;
+                if (value is null || value is DBNull) return default!;
                 return Parse((string)value);
             }
         }

Dapper/SqlMapper.TypeHandlerCache.cs

@@ -20,7 +20,7 @@ public static class TypeHandlerCache<T>
             /// </summary>
             /// <param name="value">The object to parse.</param>
             [Obsolete(ObsoleteInternalUsageOnly, true)]
-            public static T Parse(object value) => (T)handler.Parse(typeof(T), value);
+            public static T? Parse(object value) => (T?)handler.Parse(typeof(T), value);
 
             /// <summary>
             /// Not intended for direct usage.
@@ -32,12 +32,10 @@ public static class TypeHandlerCache<T>
 
             internal static void SetHandler(ITypeHandler handler)
             {
-#pragma warning disable 618
                 TypeHandlerCache<T>.handler = handler;
-#pragma warning restore 618
             }
 
-            private static ITypeHandler handler;
+            private static ITypeHandler handler = null!;
         }
     }
 }

Dapper/TableValuedParameter.cs

@@ -8,7 +8,7 @@ namespace Dapper
     internal sealed class TableValuedParameter : SqlMapper.ICustomQueryParameter
     {
         private readonly DataTable table;
-        private readonly string typeName;
+        private readonly string? typeName;
 
         /// <summary>
         /// Create a new instance of <see cref="TableValuedParameter"/>.
@@ -21,7 +21,7 @@ internal sealed class TableValuedParameter : SqlMapper.ICustomQueryParameter
         /// </summary>
         /// <param name="table">The <see cref="DataTable"/> to create this parameter for.</param>
         /// <param name="typeName">The name of the type this parameter is for.</param>
-        public TableValuedParameter(DataTable table, string typeName)
+        public TableValuedParameter(DataTable table, string? typeName)
         {
             this.table = table;
             this.typeName = typeName;
@@ -35,12 +35,12 @@ void SqlMapper.ICustomQueryParameter.AddParameter(IDbCommand command, string nam
             command.Parameters.Add(param);
         }
 
-        internal static void Set(IDbDataParameter parameter, DataTable table, string typeName)
+        internal static void Set(IDbDataParameter parameter, DataTable? table, string? typeName)
         {
 #pragma warning disable 0618
             parameter.Value = SqlMapper.SanitizeParameterValue(table);
 #pragma warning restore 0618
-            if (string.IsNullOrEmpty(typeName) && table != null)
+            if (string.IsNullOrEmpty(typeName) && table is not null)
             {
                 typeName = table.GetTypeName();
             }

Dapper/TypeExtensions.cs

@@ -5,7 +5,7 @@ namespace Dapper
 {
     internal static class TypeExtensions
     {
-        public static MethodInfo GetPublicInstanceMethod(this Type type, string name, Type[] types)
+        public static MethodInfo? GetPublicInstanceMethod(this Type type, string name, Type[] types)
             => type.GetMethod(name, BindingFlags.Instance | BindingFlags.Public, null, types, null);
     }
 }

Dapper/UdtTypeHandler.cs

@@ -22,7 +22,7 @@ public UdtTypeHandler(string udtTypeName)
                 this.udtTypeName = udtTypeName;
             }
 
-            object ITypeHandler.Parse(Type destinationType, object value)
+            object? ITypeHandler.Parse(Type destinationType, object value)
             {
                 return value is DBNull ? null : value;
             }

Dapper/WrappedReader.cs

@@ -34,18 +34,18 @@ private async static Task<T> ThrowDisposedAsync<T>()
         public override void Close() { }
         public override DataTable GetSchemaTable() => ThrowDisposed<DataTable>();
 
-#if PLAT_NO_REMOTING
+#if NET5_0_OR_GREATER
         [Obsolete("This Remoting API is not supported and throws PlatformNotSupportedException.", DiagnosticId = "SYSLIB0010", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
 #endif
         public override object InitializeLifetimeService() => ThrowDisposed<object>();
         protected override void Dispose(bool disposing) { }
         public override bool GetBoolean(int ordinal) => ThrowDisposed<bool>();
-        public override long GetBytes(int ordinal, long dataOffset, byte[] buffer, int bufferOffset, int length) => ThrowDisposed<long>();
+        public override long GetBytes(int ordinal, long dataOffset, byte[]? buffer, int bufferOffset, int length) => ThrowDisposed<long>();
         public override float GetFloat(int ordinal) => ThrowDisposed<float>();
         public override short GetInt16(int ordinal) => ThrowDisposed<short>();
         public override byte GetByte(int ordinal) => ThrowDisposed<byte>();
         public override char GetChar(int ordinal) => ThrowDisposed<char>();
-        public override long GetChars(int ordinal, long dataOffset, char[] buffer, int bufferOffset, int length) => ThrowDisposed<long>();
+        public override long GetChars(int ordinal, long dataOffset, char[]? buffer, int bufferOffset, int length) => ThrowDisposed<long>();
         public override string GetDataTypeName(int ordinal) => ThrowDisposed<string>();
         public override DateTime GetDateTime(int ordinal) => ThrowDisposed<DateTime>();
         protected override DbDataReader GetDbDataReader(int ordinal) => ThrowDisposed<DbDataReader>();
@@ -83,13 +83,13 @@ internal sealed class DbWrappedReader : DbDataReader, IWrappedDataReader
         // the purpose of wrapping here is to allow closing a reader to *also* close
         // the command, without having to explicitly hand the command back to the
         // caller
-        public static DbDataReader Create(IDbCommand cmd, DbDataReader reader)
+        public static DbDataReader Create(IDbCommand? cmd, DbDataReader reader)
         {
-            if (cmd == null) return reader; // no need to wrap if no command
+            if (cmd is null) return reader; // no need to wrap if no command
 
-            if (reader != null) return new DbWrappedReader(cmd, reader);
+            if (reader is not null) return new DbWrappedReader(cmd, reader);
             cmd.Dispose();
-            return null; // GIGO
+            return null!; // GIGO
         }
 
         private DbDataReader _reader;
@@ -108,9 +108,9 @@ public DbWrappedReader(IDbCommand cmd, DbDataReader reader)
         public override bool HasRows => _reader.HasRows;
 
         public override void Close() => _reader.Close();
-        public override DataTable GetSchemaTable() => _reader.GetSchemaTable();
+        public override DataTable? GetSchemaTable() => _reader.GetSchemaTable();
 
-#if PLAT_NO_REMOTING
+#if NET5_0_OR_GREATER
         [Obsolete("This Remoting API is not supported and throws PlatformNotSupportedException.", DiagnosticId = "SYSLIB0010", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
 #endif
         public override object InitializeLifetimeService() => _reader.InitializeLifetimeService();
@@ -133,7 +133,7 @@ protected override void Dispose(bool disposing)
                 _reader.Dispose();
                 _reader = DisposedReader.Instance; // all future ops are no-ops
                 _cmd?.Dispose();
-                _cmd = null;
+                _cmd = null!;
             }
         }
 
@@ -143,12 +143,12 @@ protected override void Dispose(bool disposing)
 
         public override byte GetByte(int i) => _reader.GetByte(i);
 
-        public override long GetBytes(int i, long fieldOffset, byte[] buffer, int bufferoffset, int length) =>
+        public override long GetBytes(int i, long fieldOffset, byte[]? buffer, int bufferoffset, int length) =>
             _reader.GetBytes(i, fieldOffset, buffer, bufferoffset, length);
 
         public override char GetChar(int i) => _reader.GetChar(i);
 
-        public override long GetChars(int i, long fieldoffset, char[] buffer, int bufferoffset, int length) =>
+        public override long GetChars(int i, long fieldoffset, char[]? buffer, int bufferoffset, int length) =>
             _reader.GetChars(i, fieldoffset, buffer, bufferoffset, length);
 
         public override string GetDataTypeName(int i) => _reader.GetDataTypeName(i);
@@ -208,7 +208,7 @@ protected override void Dispose(bool disposing)
 
         public override Task<ReadOnlyCollection<DbColumn>> GetColumnSchemaAsync(CancellationToken cancellationToken = default) => _reader.GetColumnSchemaAsync(cancellationToken);
 
-        public override Task<DataTable> GetSchemaTableAsync(CancellationToken cancellationToken = default) => base.GetSchemaTableAsync(cancellationToken);
+        public override Task<DataTable?> GetSchemaTableAsync(CancellationToken cancellationToken = default) => base.GetSchemaTableAsync(cancellationToken);
 #endif
     }
 
@@ -224,9 +224,9 @@ public WrappedBasicReader(IDataReader reader)
 
         public override bool HasRows => true; // have to assume that we do
         public override void Close() => _reader.Close();
-        public override DataTable GetSchemaTable() => _reader.GetSchemaTable();
+        public override DataTable? GetSchemaTable() => _reader.GetSchemaTable();
 
-#if PLAT_NO_REMOTING
+#if NET5_0_OR_GREATER
         [Obsolete("This Remoting API is not supported and throws PlatformNotSupportedException.", DiagnosticId = "SYSLIB0010", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
 #endif
         public override object InitializeLifetimeService() => throw new NotSupportedException();
@@ -257,13 +257,13 @@ protected override void Dispose(bool disposing)
 
         public override byte GetByte(int i) => _reader.GetByte(i);
 
-        public override long GetBytes(int i, long fieldOffset, byte[] buffer, int bufferoffset, int length) =>
-            _reader.GetBytes(i, fieldOffset, buffer, bufferoffset, length);
+        public override long GetBytes(int i, long fieldOffset, byte[]? buffer, int bufferoffset, int length) =>
+            _reader.GetBytes(i, fieldOffset, buffer!, bufferoffset, length);
 
         public override char GetChar(int i) => _reader.GetChar(i);
 
-        public override long GetChars(int i, long fieldoffset, char[] buffer, int bufferoffset, int length) =>
-            _reader.GetChars(i, fieldoffset, buffer, bufferoffset, length);
+        public override long GetChars(int i, long fieldoffset, char[]? buffer, int bufferoffset, int length) =>
+            _reader.GetChars(i, fieldoffset, buffer!, bufferoffset, length);
 
         public override string GetDataTypeName(int i) => _reader.GetDataTypeName(i);
 
@@ -308,7 +308,7 @@ public override T GetFieldValue<T>(int ordinal)
             {
                 value = null;
             }
-            return (T)value;
+            return (T)value!;
         }
         public override Task<T> GetFieldValueAsync<T>(int ordinal, CancellationToken cancellationToken)
         {
@@ -356,7 +356,7 @@ public override ValueTask DisposeAsync()
         public override Task<ReadOnlyCollection<DbColumn>> GetColumnSchemaAsync(CancellationToken cancellationToken = default)
             => throw new NotSupportedException();
 
-        public override Task<DataTable> GetSchemaTableAsync(CancellationToken cancellationToken = default)
+        public override Task<DataTable?> GetSchemaTableAsync(CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
             return Task.FromResult(_reader.GetSchemaTable());

Dapper/XmlHandlers.cs

@@ -6,7 +6,7 @@ namespace Dapper
 {
     internal abstract class XmlTypeHandler<T> : SqlMapper.StringTypeHandler<T>
     {
-        public override void SetValue(IDbDataParameter parameter, T value)
+        public override void SetValue(IDbDataParameter parameter, T? value)
         {
             base.SetValue(parameter, value);
             parameter.DbType = DbType.Xml;

Directory.Build.props

@@ -19,11 +19,12 @@
     <DebugType>embedded</DebugType>
     <DefaultLanguage>en-US</DefaultLanguage>
     <IncludeSymbols>false</IncludeSymbols>
-
+    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
-
     <LangVersion>9.0</LangVersion>
     <CheckEolTargetFramework>false</CheckEolTargetFramework>
+    <SuppressNETCoreSdkPreviewMessage>true</SuppressNETCoreSdkPreviewMessage>
+    <PackageReadmeFile>readme.md</PackageReadmeFile>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)' == 'Release'">
@@ -36,12 +37,12 @@
   </ItemGroup>
   
   <ItemGroup>
-    <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" IncludeAssets="runtime; build; native; contentfiles; analyzers" />
-    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All"/>
-    <PackageReference Include="Nerdbank.GitVersioning" Version="3.3.37" PrivateAssets="all" />
-    <None Include="../Dapper.png">
-      <Pack>True</Pack>
+    <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" PrivateAssets="All" IncludeAssets="runtime; build; native; contentfiles; analyzers" />
+    <PackageReference Include="Microsoft.SourceLink.GitHub" PrivateAssets="All"/>
+    <PackageReference Include="Nerdbank.GitVersioning" PrivateAssets="all" />
+    <None Include="../Dapper.png" Visible="false" Pack="true">
       <PackagePath></PackagePath>
     </None>
+    <None Include="../docs/readme.md" Link="readme.md" Pack="true" PackagePath="/" Visible="false" />
   </ItemGroup>
 </Project>
\ No newline at end of file

Directory.Packages.props

+<Project>
+    <ItemGroup>
+      <!-- note: 6.2.0 has regressions; don't force the update -->
+      <PackageVersion Include="EntityFramework" Version="6.1.3" />
+      <PackageVersion Include="Microsoft.CSharp" Version="4.7.0" />
+      <PackageVersion Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" />
+      <PackageVersion Include="Microsoft.SourceLink.GitHub" Version="1.1.1" />
+      <PackageVersion Include="Microsoft.SqlServer.Types" Version="14.0.1016.290" />
+      <PackageVersion Include="Nerdbank.GitVersioning" Version="3.6.133" />
+      <PackageVersion Include="Microsoft.CodeAnalysis.PublicApiAnalyzers" Version="3.3.4" />
+      <PackageVersion Include="System.Reflection.Emit.Lightweight" Version="4.7.0" />
+      
+      <!-- tests -->
+      <PackageVersion Include="Belgrade.Sql.Client" Version="1.1.4" />
+      <PackageVersion Include="BenchmarkDotNet" Version="0.13.7" />
+      <PackageVersion Include="Dashing" Version="2.10.0" />
+      <PackageVersion Include="Dapper.Contrib" Version="2.0.78" />
+      <PackageVersion Include="DevExpress.Xpo" Version="23.1.4" />
+      <PackageVersion Include="FirebirdSql.Data.FirebirdClient" Version="9.1.1" />
+      <PackageVersion Include="GitHubActionsTestLogger" Version="2.3.2" />
+      <PackageVersion Include="Iesi.Collections" Version="4.0.5" />
+      <PackageVersion Include="linq2db.SqlServer" Version="3.7.0" />
+      <PackageVersion Include="Microsoft.Data.SqlClient" Version="5.1.1" />
+      <PackageVersion Include="Microsoft.Data.Sqlite" Version="7.0.10" />
+      <PackageVersion Include="Microsoft.EntityFrameworkCore.SqlServer" Version="5.0.0" />
+      <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.7.1" />
+      <PackageVersion Include="Mighty" Version="3.2.0" />
+      <PackageVersion Include="MySqlConnector" Version="2.2.7" />
+      <PackageVersion Include="NHibernate" Version="5.4.5" />
+      <PackageVersion Include="Norm.net" Version="5.3.7" />
+      <PackageVersion Include="Npgsql" Version="7.0.4" />
+      <PackageVersion Include="PetaPoco" Version="5.1.306" />
+      <PackageVersion Include="RepoDb.SqlServer" Version="1.13.1" />
+      <PackageVersion Include="ServiceStack.OrmLite.SqlServer" Version="6.10.0" />
+      <PackageVersion Include="Snowflake.Data" Version="2.1.0" />
+      <PackageVersion Include="SqlMarshal" Version="0.4.4" />
+      <PackageVersion Include="SubSonic" Version="3.0.0.4" />
+      <PackageVersion Include="Susanoo.SqlServer" Version="1.2.4.2" />
+      <PackageVersion Include="System.Data.SqlClient" Version="4.8.5" />
+      <PackageVersion Include="System.Data.SQLite" Version="1.0.118" />
+      <PackageVersion Include="System.ValueTuple" Version="4.5.0" />
+      <PackageVersion Include="xunit" Version="2.5.0" />
+      <PackageVersion Include="xunit.runner.visualstudio" Version="2.5.0" />
+    </ItemGroup>
+</Project>
\ No newline at end of file

Readme.md

@@ -368,7 +368,7 @@ Ansi Strings and varchar
 Dapper supports varchar params, if you are executing a where clause on a varchar column using a param be sure to pass it in this way:
 
 ```csharp
-Query<Thing>("select * from Thing where Name = @Name", new {Name = new DbString { Value = "abcde", IsFixedLength = true, Length = 10, IsAnsi = true });
+Query<Thing>("select * from Thing where Name = @Name", new {Name = new DbString { Value = "abcde", IsFixedLength = true, Length = 10, IsAnsi = true }});
 ```
 
 On SQL Server it is crucial to use the unicode when querying unicode and ANSI when querying non unicode.

benchmarks/Dapper.Tests.Performance/Benchmarks.Linq2DB.cs

@@ -10,7 +10,7 @@
 namespace Dapper.Tests.Performance
 {
     [Description("LINQ to DB")]
-    public class Linq2DBBenchmarks : BenchmarkBase
+    public class LinqToDBBenchmarks : BenchmarkBase // note To not 2 because the "2" confuses BDN CLI
     {
         private Linq2DBContext _dbContext;
 

benchmarks/Dapper.Tests.Performance/Benchmarks.Linq2Sql.cs

@@ -9,7 +9,7 @@
 namespace Dapper.Tests.Performance
 {
     [Description("LINQ to SQL")]
-    public class Linq2SqlBenchmarks : BenchmarkBase
+    public class LinqToSqlBenchmarks : BenchmarkBase // note To not 2 because the "2" confuses BDN CLI
     {
         private DataClassesDataContext Linq2SqlContext;
 

benchmarks/Dapper.Tests.Performance/Benchmarks.RepoDB.cs

@@ -12,7 +12,7 @@ public class RepoDbBenchmarks : BenchmarkBase
         public void Setup()
         {
             BaseSetup();
-            SqlServerBootstrap.Initialize();
+            GlobalConfiguration.Setup().UseSqlServer();
             ClassMapper.Add<Post>("Posts");
         }
 

benchmarks/Dapper.Tests.Performance/Dapper.Tests.Performance.csproj

@@ -3,30 +3,31 @@
     <AssemblyName>Dapper.Tests.Performance</AssemblyName>
     <Description>Dapper Core Performance Suite</Description>
     <OutputType>Exe</OutputType>
-    <TargetFrameworks>net462;netcoreapp3.1</TargetFrameworks>
+    <TargetFrameworks>net462;net5.0</TargetFrameworks>
     <IsTestProject>false</IsTestProject>
     <NoWarn>$(NoWarn);IDE0063;IDE0034;IDE0059;IDE0060</NoWarn>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="Dashing" Version="2.4.3" />
-    <PackageReference Include="Belgrade.Sql.Client" Version="1.1.4" />
-    <PackageReference Include="BenchmarkDotNet" Version="0.12.1" />
-    <PackageReference Include="DevExpress.Xpo" Version="20.2.3" />
     <!--<PackageReference Include="BLToolkit" Version="4.3.6" />-->
-    <PackageReference Include="EntityFramework" Version="6.4.4" />
-    <PackageReference Include="FirebirdSql.Data.FirebirdClient" Version="7.5.0" />
-    <PackageReference Include="linq2db.SqlServer" Version="3.1.6" />
-    <PackageReference Include="MySqlConnector" Version="1.1.0" />
-    <PackageReference Include="NHibernate" Version="5.3.5" />
-    <PackageReference Include="Iesi.Collections" Version="4.0.4" />
-    <PackageReference Include="Mighty" Version="3.1.3" />
-    <PackageReference Include="Npgsql" Version="5.0.0" />
-    <PackageReference Include="PetaPoco" Version="5.1.306" />
-    <PackageReference Include="RepoDb.SqlServer" Version="1.1.4" />
-    <PackageReference Include="ServiceStack.OrmLite.SqlServer" Version="5.10.2" />
-    <PackageReference Include="SqlMarshal" Version="0.2.0" />
-    <PackageReference Include="System.Data.SqlClient" Version="4.8.3" />
-    <PackageReference Include="System.Data.SQLite" Version="1.0.113.6" />
+
+    <PackageReference Include="Dashing" />
+    <PackageReference Include="Belgrade.Sql.Client" />
+    <PackageReference Include="BenchmarkDotNet" />
+    <PackageReference Include="DevExpress.Xpo" />
+    <PackageReference Include="EntityFramework" VersionOverride="6.4.4"/>
+    <PackageReference Include="FirebirdSql.Data.FirebirdClient" />
+    <PackageReference Include="linq2db.SqlServer" />
+    <PackageReference Include="MySqlConnector" />
+    <PackageReference Include="NHibernate" />
+    <PackageReference Include="Iesi.Collections" />
+    <PackageReference Include="Mighty" />
+    <PackageReference Include="Npgsql" />
+    <PackageReference Include="PetaPoco" />
+    <PackageReference Include="RepoDb.SqlServer" />
+    <PackageReference Include="ServiceStack.OrmLite.SqlServer" />
+    <PackageReference Include="SqlMarshal" />
+    <PackageReference Include="System.Data.SqlClient" />
+    <PackageReference Include="System.Data.SQLite" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="NHibernate\*.xml" />
@@ -38,16 +39,16 @@
   </PropertyGroup>
   <ItemGroup Condition="'$(TargetFramework)' == 'net462'">
     <ProjectReference Include="../../Dapper.EntityFramework/Dapper.EntityFramework.csproj" />
-    <PackageReference Include="Microsoft.SqlServer.Types" Version="14.0.1016.290" />
-    <PackageReference Include="SubSonic" Version="3.0.0.4" />
-    <PackageReference Include="Susanoo.SqlServer" Version="1.2.4.2" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="[3.1.10]" />
+    <PackageReference Include="Microsoft.SqlServer.Types" />
+    <PackageReference Include="SubSonic" />
+    <PackageReference Include="Susanoo.SqlServer" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" VersionOverride="[3.1.10]" />
     <Reference Include="Microsoft.CSharp" />
     <Reference Include="System.Configuration" />
     <Reference Include="System.Data.Linq" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework)' != 'net462'">
-    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="5.0.0" />
-    <PackageReference Include="Norm.net" Version="3.2.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" />
+    <PackageReference Include="Norm.net" />
   </ItemGroup>
 </Project>

benchmarks/Dapper.Tests.Performance/DapperCacheImpact.cs

+using System.ComponentModel;
+using BenchmarkDotNet.Attributes;
+
+namespace Dapper.Tests.Performance
+{
+    [Description("Dapper cache impact")]
+    [MemoryDiagnoser]
+    public class DapperCacheImpact : BenchmarkBase
+    {
+        [GlobalSetup]
+        public void Setup() => BaseSetup();
+
+        private object args = new { Id = 42, Name = "abc" };
+
+        public class Foo
+        {
+            public int Id { get; set; }
+            public string Name { get; set; }
+        }
+
+        // note: custom BDN setup means [Params] is awkward; unroll manually instead
+        [Benchmark]
+        public void ExecuteNoParameters_Cache() => _connection.Execute(new CommandDefinition("select '42' as Id, 'abc' as Name", flags: CommandFlags.None));
+        [Benchmark]
+        public void ExecuteParameters_Cache() => _connection.Execute(new CommandDefinition("select @id as Id, @name as Name", args, flags: CommandFlags.None));
+        [Benchmark]
+        public void QueryFirstNoParameters_Cache() => _connection.QueryFirst<Foo>(new CommandDefinition("select '42' as Id, 'abc' as Name", flags: CommandFlags.None));
+        [Benchmark]
+        public void QueryFirstParameters_Cache() => _connection.QueryFirst<Foo>(new CommandDefinition("select @id as Id, @name as Name", args, flags: CommandFlags.None));
+        [Benchmark]
+        public void ExecuteNoParameters_NoCache() => _connection.Execute(new CommandDefinition("select '42' as Id, 'abc' as Name", flags: CommandFlags.NoCache));
+        [Benchmark]
+        public void ExecuteParameters_NoCache() => _connection.Execute(new CommandDefinition("select @id as Id, @name as Name", args, flags: CommandFlags.NoCache));
+        [Benchmark]
+        public void QueryFirstNoParameters_NoCache() => _connection.QueryFirst<Foo>(new CommandDefinition("select '42' as Id, 'abc' as Name", flags: CommandFlags.NoCache));
+        [Benchmark]
+        public void QueryFirstParameters_NoCache() => _connection.QueryFirst<Foo>(new CommandDefinition("select @id as Id, @name as Name", args, flags: CommandFlags.NoCache));
+    }
+}

benchmarks/Directory.Build.props

@@ -10,7 +10,7 @@
   
   <ItemGroup>
     <ProjectReference Include="../../Dapper/Dapper.csproj" />
-    <PackageReference Include="Dapper.Contrib" Version="2.0.78" />
+    <PackageReference Include="Dapper.Contrib" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)' == 'net461'">

docs/index.md

@@ -24,6 +24,23 @@ Note: to get the latest pre-release build, add ` -Pre` to the end of the command
 
 (note: new PRs will not be merged until they add release note wording here)
 
+### 2.1.4
+
+- add untyped `GridReader.ReadUnbufferedAsync` API (#1958 via @mgravell)
+- tweak NRT annotations on type-handler API (#1960 via @mgravell, fixes #1959)
+
+### 2.1.1
+
+- add NRT annotations (#1928 via @mgravell)
+- extend `GridReader` API to allow it to be subclassed by external consumers (#1928 via @mgravell)
+- support `$` as a parameter prefix (#1952 via @Giorgi)
+- add public API tracking (#1948 via @mgravell)
+
+### 2.0.151
+
+- add global `FetchSize` setting for use with Oracle (#1946 via mgravell, fixes #1945) (also add some missing logic in `Settings.Reset()`)
+- add underscore handling with constructors (#1786 via @jo-goro, fixes #818; also #1947 via mgravell)
+
 ### 2.0.143
 
 - add missing non-generic `AsyncEnumerable<dynamic> QueryUnbufferedAsync(...)` API (#1925 via mgravell, fixes #1922)

docs/readme.md

+# Dapper
+
+Dapper is a simple micro-ORM used to simplify working with ADO.NET; if you like SQL but dislike the boilerplate of ADO.NET: Dapper is for you!
+
+As a simple example:
+
+``` c#
+string region = ...
+var customers = connection.Query<Customer>(
+    "select * from Customers where Region = @region", // SQL
+    new { region } // parameters
+    ).AsList();
+```
+
+But all the execute/single-row/scalar/async/etc functionality you would expect: is there as extension methods on your `DbConnection`.
+
+See [GitHub](https://github.com/DapperLib/Dapper) for more information and examples.
\ No newline at end of file

nuget.config

@@ -2,7 +2,6 @@
 <configuration>
   <packageSources>
     <clear />
-    <add key="npgsql" value="https://www.myget.org/F/npgsql-unstable/api/v3/index.json" />
     <add key="NuGet" value="https://api.nuget.org/v3/index.json" />
   </packageSources>
 </configuration>
\ No newline at end of file

tests/Dapper.Tests/ConstructorTests.cs

@@ -59,9 +59,9 @@ public void TestNoDefaultConstructorWithChar()
             const char c1 = 'ą';
             const char c3 = 'ó';
             NoDefaultConstructorWithChar nodef = connection.Query<NoDefaultConstructorWithChar>("select @c1 c1, @c2 c2, @c3 c3", new { c1 = c1, c2 = (char?)null, c3 = c3 }).First();
-            Assert.Equal(nodef.Char1, c1);
+            Assert.Equal(c1, nodef.Char1);
             Assert.Null(nodef.Char2);
-            Assert.Equal(nodef.Char3, c3);
+            Assert.Equal(c3, nodef.Char3);
         }
 
         [Fact]
@@ -132,6 +132,7 @@ private class MultipleConstructors
         {
             public MultipleConstructors()
             {
+                B = default!;
             }
 
             public MultipleConstructors(int a, string b)
@@ -157,7 +158,7 @@ public ConstructorsWithAccessModifiers(int a, string b)
             }
 
             public int A { get; set; }
-            public string B { get; set; }
+            public string? B { get; set; }
         }
 
         private class NoDefaultConstructor
@@ -220,5 +221,45 @@ public void TestWithNonPublicConstructor()
             var output = connection.Query<WithPrivateConstructor>("select 1 as Foo").First();
             Assert.Equal(1, output.Foo);
         }
+
+        [Fact]
+        public void CtorWithUnderscores()
+        {
+            var obj = connection.QueryFirst<Type_ParamsWithUnderscores>("select 'abc' as FIRST_NAME, 'def' as LAST_NAME");
+            Assert.NotNull(obj);
+            Assert.Equal("abc", obj.FirstName);
+            Assert.Equal("def", obj.LastName);
+        }
+
+        [Fact]
+        public void CtorWithoutUnderscores()
+        {
+            DefaultTypeMap.MatchNamesWithUnderscores = true;
+            var obj = connection.QueryFirst<Type_ParamsWithoutUnderscores>("select 'abc' as FIRST_NAME, 'def' as LAST_NAME");
+            Assert.NotNull(obj);
+            Assert.Equal("abc", obj.FirstName);
+            Assert.Equal("def", obj.LastName);
+        }
+
+        class Type_ParamsWithUnderscores
+        {
+            public string FirstName { get; }
+            public string LastName { get; }
+            public Type_ParamsWithUnderscores(string first_name, string last_name)
+            {
+                FirstName = first_name;
+                LastName = last_name;
+            }
+        }
+        class Type_ParamsWithoutUnderscores
+        {
+            public string FirstName { get; }
+            public string LastName { get; }
+            public Type_ParamsWithoutUnderscores(string firstName, string lastName)
+            {
+                FirstName = firstName;
+                LastName = lastName;
+            }
+        }
     }
 }

tests/Dapper.Tests/Dapper.Tests.csproj

@@ -2,9 +2,10 @@
   <PropertyGroup>
     <AssemblyName>Dapper.Tests</AssemblyName>
     <Description>Dapper Core Test Suite</Description>
-    <TargetFrameworks>net462;net472;net6.0</TargetFrameworks>
+    <TargetFrameworks>net472;net6.0</TargetFrameworks>
     <DefineConstants>$(DefineConstants);MSSQLCLIENT</DefineConstants>
     <NoWarn>$(NoWarn);IDE0017;IDE0034;IDE0037;IDE0039;IDE0042;IDE0044;IDE0051;IDE0052;IDE0059;IDE0060;IDE0063;IDE1006;xUnit1004;CA1806;CA1816;CA1822;CA1825;CA2208</NoWarn>
+    <Nullable>enable</Nullable>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(TargetFramework)' == 'net462' OR '$(TargetFramework)' == 'net472'">
@@ -14,14 +15,17 @@
   <ItemGroup>
     <ProjectReference Include="../../Dapper.ProviderTools/Dapper.ProviderTools.csproj" />
     <ProjectReference Include="../../Dapper.SqlBuilder/Dapper.SqlBuilder.csproj" />
-    <PackageReference Include="FirebirdSql.Data.FirebirdClient" Version="7.5.0" />
-    <PackageReference Include="Microsoft.Data.SqlClient" Version="2.0.1" />
-    <PackageReference Include="Microsoft.Data.Sqlite" Version="5.0.0" />
-    <PackageReference Include="MySqlConnector" Version="1.1.0" />
-    <PackageReference Include="Npgsql" Version="6.0.0" />
-    <PackageReference Include="Snowflake.Data" Version="2.0.3" />
-    <PackageReference Include="System.Data.SqlClient" Version="4.8.2" />
-    <PackageReference Include="System.ValueTuple" Version="4.5.0" />
+    <PackageReference Include="FirebirdSql.Data.FirebirdClient" />
+    <PackageReference Include="Microsoft.Data.SqlClient" />
+    <PackageReference Include="Microsoft.Data.Sqlite" />
+    <PackageReference Include="MySqlConnector" />
+    <PackageReference Include="Npgsql" />
+    <PackageReference Include="System.Data.SqlClient" />
+    <PackageReference Include="System.ValueTuple" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' != 'net462'">
+    <PackageReference Include="Snowflake.Data" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)' == 'net462' OR '$(TargetFramework)' == 'net472'">

tests/Dapper.Tests/DataReaderTests.cs

@@ -131,7 +131,7 @@ union all
             var foo = (Discriminated_Foo)result[0];
             Assert.Equal("abc", foo.Name);
             var bar = (Discriminated_Bar)result[1];
-            Assert.Equal(bar.Value, (float)4.0);
+            Assert.Equal((float)4.0, bar.Value);
         }
 
         [Fact]
@@ -170,7 +170,7 @@ union all
             var foo = (Discriminated_Foo)result[0];
             Assert.Equal("abc", foo.Name);
             var bar = (Discriminated_Bar)result[1];
-            Assert.Equal(bar.Value, (float)4.0);
+            Assert.Equal((float)4.0, bar.Value);
         }
 
         [Fact]
@@ -195,7 +195,7 @@ union all
 
                     do
                     {
-                        DiscriminatedWithMultiMapping_BaseType obj = null;
+                        DiscriminatedWithMultiMapping_BaseType? obj = null;
                         switch (reader.GetInt32(col))
                         {
                             case 1:
@@ -207,7 +207,7 @@ union all
                         }
 
                         Assert.NotNull(obj);
-                        obj.HazNameIdObject = toHaz(reader);
+                        obj!.HazNameIdObject = toHaz(reader);
                         result.Add(obj);
 
                     } while (reader.Read());
@@ -219,10 +219,12 @@ union all
             Assert.Equal(2, result[1].Type);
             var foo = (DiscriminatedWithMultiMapping_Foo)result[0];
             Assert.Equal("abc", foo.Name);
+            Assert.NotNull(foo.HazNameIdObject);
             Assert.Equal(1, foo.HazNameIdObject.Id);
-            Assert.Equal("zxc", foo.HazNameIdObject.Name);
+            Assert.Equal("zxc", foo.HazNameIdObject!.Name);
             var bar = (DiscriminatedWithMultiMapping_Bar)result[1];
-            Assert.Equal(bar.Value, (float)4.0);
+            Assert.Equal((float)4.0, bar.Value);
+            Assert.NotNull(bar.HazNameIdObject);
             Assert.Equal(2, bar.HazNameIdObject.Id);
             Assert.Equal("qwe", bar.HazNameIdObject.Name);
         }
@@ -247,7 +249,7 @@ union all
 
                     do
                     {
-                        DiscriminatedWithMultiMapping_BaseType obj = null;
+                        DiscriminatedWithMultiMapping_BaseType? obj = null;
                         switch (reader.GetInt32(col))
                         {
                             case 1:
@@ -271,10 +273,12 @@ union all
             Assert.Equal(2, result[1].Type);
             var foo = (DiscriminatedWithMultiMapping_Foo)result[0];
             Assert.Equal("abc", foo.Name);
+            Assert.NotNull(foo.HazNameIdObject);
             Assert.Equal(1, foo.HazNameIdObject.Id);
             Assert.Equal("zxc", foo.HazNameIdObject.Name);
             var bar = (DiscriminatedWithMultiMapping_Bar)result[1];
-            Assert.Equal(bar.Value, (float)4.0);
+            Assert.Equal((float)4.0, bar.Value);
+            Assert.NotNull(bar.HazNameIdObject);
             Assert.Equal(2, bar.HazNameIdObject.Id);
             Assert.Equal("qwe", bar.HazNameIdObject.Name);
         }
@@ -286,7 +290,7 @@ private abstract class Discriminated_BaseType
 
         private class Discriminated_Foo : Discriminated_BaseType
         {
-            public string Name { get; set; }
+            public string? Name { get; set; }
             public override int Type => 1;
         }
 
@@ -298,19 +302,19 @@ private class Discriminated_Bar : Discriminated_BaseType
 
         private abstract class DiscriminatedWithMultiMapping_BaseType : Discriminated_BaseType
         {
-            public abstract HazNameId HazNameIdObject { get; set; }
+            public abstract HazNameId? HazNameIdObject { get; set; }
         }
 
         private class DiscriminatedWithMultiMapping_Foo : DiscriminatedWithMultiMapping_BaseType
         {
-            public override HazNameId HazNameIdObject { get; set; }
-            public string Name { get; set; }
+            public override HazNameId? HazNameIdObject { get; set; }
+            public string? Name { get; set; }
             public override int Type => 1;
         }
 
         private class DiscriminatedWithMultiMapping_Bar : DiscriminatedWithMultiMapping_BaseType
         {
-            public override HazNameId HazNameIdObject { get; set; }
+            public override HazNameId? HazNameIdObject { get; set; }
             public float Value { get; set; }
             public override int Type => 2;
         }

tests/Dapper.Tests/DecimalTests.cs

@@ -20,7 +20,7 @@ public void Issue261_Decimals()
             parameters.Add("c", dbType: DbType.Decimal, direction: ParameterDirection.Output, precision: 10, scale: 5);
             connection.Execute("create proc #Issue261 @c decimal(10,5) OUTPUT as begin set @c=11.884 end");
             connection.Execute("#Issue261", parameters, commandType: CommandType.StoredProcedure);
-            var c = parameters.Get<Decimal>("c");
+            var c = parameters.Get<decimal>("c");
             Assert.Equal(11.884M, c);
         }
 
@@ -34,11 +34,9 @@ private void Issue261_Decimals_ADONET(bool setPrecisionScaleViaAbstractApi)
         {
             try
             {
-                using (var cmd = connection.CreateCommand())
-                {
-                    cmd.CommandText = "create proc #Issue261Direct @c decimal(10,5) OUTPUT as begin set @c=11.884 end";
-                    cmd.ExecuteNonQuery();
-                }
+                using var cmd = connection.CreateCommand();
+                cmd.CommandText = "create proc #Issue261Direct @c decimal(10,5) OUTPUT as begin set @c=11.884 end";
+                cmd.ExecuteNonQuery();
             }
             catch { /* we don't care that it already exists */ }
 

tests/Dapper.Tests/EnumTests.cs

@@ -92,18 +92,17 @@ private class TestEnumClassNoNull
         [Fact]
         public void AdoNetEnumValue()
         {
-            using (var cmd = connection.CreateCommand())
-            {
-                cmd.CommandText = "select @foo";
-                var p = cmd.CreateParameter();
-                p.ParameterName = "@foo";
-                p.DbType = DbType.Int32; // it turns out that this is the key piece; setting the DbType
-                p.Value = AnEnum.B;
-                cmd.Parameters.Add(p);
-                object value = cmd.ExecuteScalar();
-                AnEnum val = (AnEnum)value;
-                Assert.Equal(AnEnum.B, val);
-            }
+            using var cmd = connection.CreateCommand();
+            cmd.CommandText = "select @foo";
+            var p = cmd.CreateParameter();
+            p.ParameterName = "@foo";
+            p.DbType = DbType.Int32; // it turns out that this is the key piece; setting the DbType
+            p.Value = AnEnum.B;
+            cmd.Parameters.Add(p);
+            object? value = cmd.ExecuteScalar();
+            Assert.NotNull(value);
+            AnEnum val = (AnEnum)value;
+            Assert.Equal(AnEnum.B, val);
         }
 
         [Fact]

tests/Dapper.Tests/Helpers/Attributes.cs

@@ -41,7 +41,7 @@ public FactLongRunningAttribute()
 #endif
         }
 
-        public string Url { get; private set; }
+        public string? Url { get; private set; }
     }
 
     [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
@@ -59,14 +59,12 @@ public FactRequiredCompatibilityLevelAttribute(int level) : base()
         public static readonly int DetectedLevel;
         static FactRequiredCompatibilityLevelAttribute()
         {
-            using (var conn = DatabaseProvider<SystemSqlClientProvider>.Instance.GetOpenConnection())
+            using var conn = DatabaseProvider<SystemSqlClientProvider>.Instance.GetOpenConnection();
+            try
             {
-                try
-                {
-                    DetectedLevel = conn.QuerySingle<int>("SELECT compatibility_level FROM sys.databases where name = DB_NAME()");
-                }
-                catch { /* don't care */ }
+                DetectedLevel = conn.QuerySingle<int>("SELECT compatibility_level FROM sys.databases where name = DB_NAME()");
             }
+            catch { /* don't care */ }
         }
     }
 
@@ -84,20 +82,18 @@ public FactUnlessCaseSensitiveDatabaseAttribute() : base()
         public static readonly bool IsCaseSensitive;
         static FactUnlessCaseSensitiveDatabaseAttribute()
         {
-            using (var conn = DatabaseProvider<SystemSqlClientProvider>.Instance.GetOpenConnection())
+            using var conn = DatabaseProvider<SystemSqlClientProvider>.Instance.GetOpenConnection();
+            try
             {
-                try
-                {
-                    conn.Execute("declare @i int; set @I = 1;");
-                }
-                catch (Exception ex) when (ex.GetType().Name == "SqlException")
-                {
-                    int err = ((dynamic)ex).Number;
-                    if (err == 137)
-                        IsCaseSensitive = true;
-                    else
-                        throw;
-                }
+                conn.Execute("declare @i int; set @I = 1;");
+            }
+            catch (Exception ex) when (ex.GetType().Name == "SqlException")
+            {
+                int err = ((dynamic)ex).Number;
+                if (err == 137)
+                    IsCaseSensitive = true;
+                else
+                    throw;
             }
         }
     }

tests/Dapper.Tests/Helpers/Common.cs

@@ -24,14 +24,14 @@ public static void DapperEnumValue(IDbConnection connection)
 
             // test passing as int, reading as AnEnum
             var k = (int)connection.QuerySingle<AnEnum>("select @v, @y, @z", new { v = (int)AnEnum.B, y = (int?)(int)AnEnum.B, z = (int?)null });
-            Assert.Equal(k, (int)AnEnum.B);
+            Assert.Equal((int)AnEnum.B, k);
 
             args = new DynamicParameters();
             args.Add("v", (int)AnEnum.B);
             args.Add("y", (int)AnEnum.B);
             args.Add("z", null);
             k = (int)connection.QuerySingle<AnEnum>("select @v, @y, @z", args);
-            Assert.Equal(k, (int)AnEnum.B);
+            Assert.Equal((int)AnEnum.B, k);
         }
 
         public static void TestDateTime(DbConnection connection)

tests/Dapper.Tests/LiteralTests.cs

@@ -86,7 +86,7 @@ public void LiteralReplacement()
             var count = connection.Query<int>("select count(1) from #literal1 where id={=foo}", new { foo = 123 }).Single();
             Assert.Equal(1, count);
             int sum = connection.Query<int>("select sum(id) + sum(foo) from #literal1").Single();
-            Assert.Equal(sum, 123 + 456 + 1 + 2 + 3 + 4);
+            Assert.Equal(123 + 456 + 1 + 2 + 3 + 4, sum);
         }
 
         [Fact]