Now onto fixing async C# 6 errors

mythz · mythz · commit ab2e478614b0 · 2016-06-07T13:22:28.000-04:00
diff --git a/src/ServiceStack.OrmLite/Dapper/SqlMapper.Async.cs b/src/ServiceStack.OrmLite/Dapper/SqlMapper.Async.cs
@@ -111,7 +111,7 @@ public static Task<T> QuerySingleOrDefaultAsync<T>(this IDbConnection cnn, strin
         /// </summary>
         public static Task<IEnumerable<object>> QueryAsync(this IDbConnection cnn, Type type, string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null)
         {
-            if (type == null) throw new ArgumentNullException(nameof(type));
+            if (type == null) throw new ArgumentNullException("type");
             return QueryAsync<object>(cnn, type, new CommandDefinition(sql, param, transaction, commandTimeout, commandType, CommandFlags.Buffered, default(CancellationToken)));
         }
 
@@ -120,31 +120,31 @@ public static Task<IEnumerable<object>> QueryAsync(this IDbConnection cnn, Type
         /// </summary>
         public static Task<object> QueryFirstAsync(this IDbConnection cnn, Type type, string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null)
         {
-            if (type == null) throw new ArgumentNullException(nameof(type));
+            if (type == null) throw new ArgumentNullException("type");
             return QueryRowAsync<object>(cnn, Row.First, type, new CommandDefinition(sql, param, transaction, commandTimeout, commandType, CommandFlags.None, default(CancellationToken)));
         }
         /// <summary>
         /// Execute a single-row query asynchronously using .NET 4.5 Task.
         /// </summary>
         public static Task<object> QueryFirstOrDefaultAsync(this IDbConnection cnn, Type type, string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null)
         {
-            if (type == null) throw new ArgumentNullException(nameof(type));
+            if (type == null) throw new ArgumentNullException("type");
             return QueryRowAsync<object>(cnn, Row.FirstOrDefault, type, new CommandDefinition(sql, param, transaction, commandTimeout, commandType, CommandFlags.None, default(CancellationToken)));
         }
         /// <summary>
         /// Execute a single-row query asynchronously using .NET 4.5 Task.
         /// </summary>
         public static Task<object> QuerySingleAsync(this IDbConnection cnn, Type type, string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null)
         {
-            if (type == null) throw new ArgumentNullException(nameof(type));
+            if (type == null) throw new ArgumentNullException("type");
             return QueryRowAsync<object>(cnn, Row.Single, type, new CommandDefinition(sql, param, transaction, commandTimeout, commandType, CommandFlags.None, default(CancellationToken)));
         }
         /// <summary>
         /// Execute a single-row query asynchronously using .NET 4.5 Task.
         /// </summary>
         public static Task<object> QuerySingleOrDefaultAsync(this IDbConnection cnn, Type type, string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null)
         {
-            if (type == null) throw new ArgumentNullException(nameof(type));
+            if (type == null) throw new ArgumentNullException("type");
             return QueryRowAsync<object>(cnn, Row.SingleOrDefault, type, new CommandDefinition(sql, param, transaction, commandTimeout, commandType, CommandFlags.None, default(CancellationToken)));
         }
 
@@ -205,7 +205,7 @@ private static Task<DbDataReader> ExecuteReaderWithFlagsFallbackAsync(DbCommand
         private static async Task<IEnumerable<T>> QueryAsync<T>(this IDbConnection cnn, Type effectiveType, CommandDefinition command)
         {
             object param = command.Parameters;
-            var identity = new Identity(command.CommandText, command.CommandType, cnn, effectiveType, param?.GetType(), null);
+            var identity = new Identity(command.CommandText, command.CommandType, cnn, effectiveType, param != null ? param.GetType() : null, null);
             var info = GetCacheInfo(identity, param, command.AddToCache);
             bool wasClosed = cnn.State == ConnectionState.Closed;
             var cancel = command.CancellationToken;
@@ -267,7 +267,7 @@ private static async Task<IEnumerable<T>> QueryAsync<T>(this IDbConnection cnn,
         private static async Task<T> QueryRowAsync<T>(this IDbConnection cnn, Row row, Type effectiveType, CommandDefinition command)
         {
             object param = command.Parameters;
-            var identity = new Identity(command.CommandText, command.CommandType, cnn, effectiveType, param?.GetType(), null);
+            var identity = new Identity(command.CommandText, command.CommandType, cnn, effectiveType, param != null ? param.GetType() : null, null);
             var info = GetCacheInfo(identity, param, command.AddToCache);
             bool wasClosed = cnn.State == ConnectionState.Closed;
             var cancel = command.CancellationToken;
@@ -452,7 +452,7 @@ private static async Task<int> ExecuteMultiImplAsync(IDbConnection cnn, CommandD
         }
         private static async Task<int> ExecuteImplAsync(IDbConnection cnn, CommandDefinition command, object param)
         {
-            var identity = new Identity(command.CommandText, command.CommandType, cnn, null, param?.GetType(), null);
+            var identity = new Identity(command.CommandText, command.CommandType, cnn, null, param != null ? param.GetType() : null, null);
             var info = GetCacheInfo(identity, param, command.AddToCache);
             bool wasClosed = cnn.State == ConnectionState.Closed;
             using (var cmd = (DbCommand)command.SetupCommand(cnn, info.ParamReader))
@@ -645,7 +645,7 @@ public static Task<IEnumerable<TReturn>> QueryAsync<TFirst, TSecond, TThird, TFo
         private static async Task<IEnumerable<TReturn>> MultiMapAsync<TFirst, TSecond, TThird, TFourth, TFifth, TSixth, TSeventh, TReturn>(this IDbConnection cnn, CommandDefinition command, Delegate map, string splitOn)
         {
             object param = command.Parameters;
-            var identity = new Identity(command.CommandText, command.CommandType, cnn, typeof(TFirst), param?.GetType(), new[] { typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh) });
+            var identity = new Identity(command.CommandText, command.CommandType, cnn, typeof(TFirst), param != null ? param.GetType() : null, new[] { typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh) });
             var info = GetCacheInfo(identity, param, command.AddToCache);
             bool wasClosed = cnn.State == ConnectionState.Closed;
             try
@@ -693,7 +693,7 @@ private static async Task<IEnumerable<TReturn>> MultiMapAsync<TReturn>(this IDbC
             }
 
             object param = command.Parameters;
-            var identity = new Identity(command.CommandText, command.CommandType, cnn, types[0], param?.GetType(), types);
+            var identity = new Identity(command.CommandText, command.CommandType, cnn, types[0], param != null ? param.GetType() : null, types);
             var info = GetCacheInfo(identity, param, command.AddToCache);
             bool wasClosed = cnn.State == ConnectionState.Closed;
             try {
@@ -718,7 +718,8 @@ private static IEnumerable<T> ExecuteReaderSync<T>(IDataReader reader, Func<IDat
                     yield return (T)func(reader);
                 }
                 while (reader.NextResult()) { }
-                (parameters as IParameterCallbacks)?.OnCompleted();
+                var callbacks = parameters as IParameterCallbacks;
+                if (callbacks != null) callbacks.OnCompleted();
             }
         }
 
@@ -739,7 +740,7 @@ public static Task<GridReader> QueryMultipleAsync(
         public static async Task<GridReader> QueryMultipleAsync(this IDbConnection cnn, CommandDefinition command)
         {
             object param = command.Parameters;
-            Identity identity = new Identity(command.CommandText, command.CommandType, cnn, typeof(GridReader), param?.GetType(), null);
+            Identity identity = new Identity(command.CommandText, command.CommandType, cnn, typeof(GridReader), param != null ? param.GetType() : null, null);
             CacheInfo info = GetCacheInfo(identity, param, command.AddToCache);
 
             DbCommand cmd = null;
@@ -833,7 +834,7 @@ private static async Task<IDataReader> ExecuteReaderImplAsync(IDbConnection cnn,
             finally
             {
                 if (wasClosed) cnn.Close();
-                cmd?.Dispose();
+                if (cmd != null) cmd.Dispose();
             }
         }
 
@@ -903,7 +904,7 @@ private static async Task<T> ExecuteScalarImplAsync<T>(IDbConnection cnn, Comman
             finally
             {
                 if (wasClosed) cnn.Close();
-                cmd?.Dispose();
+                if (cmd != null) cmd.Dispose();
             }
             return Parse<T>(result);
         }
diff --git a/src/ServiceStack.OrmLite/Dapper/SqlMapper.GridReader.Async.cs b/src/ServiceStack.OrmLite/Dapper/SqlMapper.GridReader.Async.cs
@@ -72,7 +72,7 @@ public Task<dynamic> ReadSingleOrDefaultAsync()
             /// </summary>
             public Task<IEnumerable<object>> ReadAsync(Type type, bool buffered = true)
             {
-                if (type == null) throw new ArgumentNullException(nameof(type));
+                if (type == null) throw new ArgumentNullException("type");
                 return ReadAsyncImpl<object>(type, buffered);
             }
 
@@ -81,31 +81,31 @@ public Task<IEnumerable<object>> ReadAsync(Type type, bool buffered = true)
             /// </summary>
             public Task<object> ReadFirstAsync(Type type)
             {
-                if (type == null) throw new ArgumentNullException(nameof(type));
+                if (type == null) throw new ArgumentNullException("type");
                 return ReadRowAsyncImpl<object>(type, Row.First);
             }
             /// <summary>
             /// Read an individual row of the next grid of results
             /// </summary>
             public Task<object> ReadFirstOrDefaultAsync(Type type)
             {
-                if (type == null) throw new ArgumentNullException(nameof(type));
+                if (type == null) throw new ArgumentNullException("type");
                 return ReadRowAsyncImpl<object>(type, Row.FirstOrDefault);
             }
             /// <summary>
             /// Read an individual row of the next grid of results
             /// </summary>
             public Task<object> ReadSingleAsync(Type type)
             {
-                if (type == null) throw new ArgumentNullException(nameof(type));
+                if (type == null) throw new ArgumentNullException("type");
                 return ReadRowAsyncImpl<object>(type, Row.Single);
             }
             /// <summary>
             /// Read an individual row of the next grid of results
             /// </summary>
             public Task<object> ReadSingleOrDefaultAsync(Type type)
             {
-                if (type == null) throw new ArgumentNullException(nameof(type));
+                if (type == null) throw new ArgumentNullException("type");
                 return ReadRowAsyncImpl<object>(type, Row.SingleOrDefault);
             }
 
@@ -160,7 +160,7 @@ private async Task NextResultAsync()
                     // need for "Cancel" etc
                     reader.Dispose();
                     reader = null;
-                    callbacks?.OnCompleted();
+                    if (callbacks != null) callbacks.OnCompleted();
                     Dispose();
                 }
             }
@@ -234,23 +234,23 @@ private async Task<T> ReadRowAsyncImplViaDbReader<T>(DbDataReader reader, Type t
 
             private async Task<IEnumerable<T>> ReadBufferedAsync<T>(int index, Func<IDataReader, object> deserializer, Identity typedIdentity)
             {
-                try
-                {
+                //try
+                //{
                     var reader = (DbDataReader)this.reader;
                     List<T> buffer = new List<T>();
                     while (index == gridIndex && await reader.ReadAsync(cancel).ConfigureAwait(false))
                     {
                         buffer.Add((T)deserializer(reader));
                     }
                     return buffer;
-                }
-                finally // finally so that First etc progresses things even when multiple rows
-                {
-                    if (index == gridIndex)
-                    {
-                        await NextResultAsync().ConfigureAwait(false);
-                    }
-                }
+                //}
+                //finally // finally so that First etc progresses things even when multiple rows
+                //{
+                //    if (index == gridIndex)
+                //    {
+                //        await NextResultAsync().ConfigureAwait(false);
+                //    }
+                //}
             }
         }
 

Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ public static Task<T> QuerySingleOrDefaultAsync<T>(this IDbConnection cnn, strin`
`111`	`111`	`/// </summary>`
`112`	`112`	`public static Task<IEnumerable<object>> QueryAsync(this IDbConnection cnn, Type type, string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null)`
`113`	`113`	`{`
`114`		`- if (type == null) throw new ArgumentNullException(nameof(type));`
	`114`	`+ if (type == null) throw new ArgumentNullException("type");`
`115`	`115`	`return QueryAsync<object>(cnn, type, new CommandDefinition(sql, param, transaction, commandTimeout, commandType, CommandFlags.Buffered, default(CancellationToken)));`
`116`	`116`	`}`
`117`	`117`
`@@ -120,31 +120,31 @@ public static Task<IEnumerable<object>> QueryAsync(this IDbConnection cnn, Type`
`120`	`120`	`/// </summary>`
`121`	`121`	`public static Task<object> QueryFirstAsync(this IDbConnection cnn, Type type, string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null)`
`122`	`122`	`{`
`123`		`- if (type == null) throw new ArgumentNullException(nameof(type));`
	`123`	`+ if (type == null) throw new ArgumentNullException("type");`
`124`	`124`	`return QueryRowAsync<object>(cnn, Row.First, type, new CommandDefinition(sql, param, transaction, commandTimeout, commandType, CommandFlags.None, default(CancellationToken)));`
`125`	`125`	`}`
`126`	`126`	`/// <summary>`
`127`	`127`	`/// Execute a single-row query asynchronously using .NET 4.5 Task.`
`128`	`128`	`/// </summary>`
`129`	`129`	`public static Task<object> QueryFirstOrDefaultAsync(this IDbConnection cnn, Type type, string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null)`
`130`	`130`	`{`
`131`		`- if (type == null) throw new ArgumentNullException(nameof(type));`
	`131`	`+ if (type == null) throw new ArgumentNullException("type");`
`132`	`132`	`return QueryRowAsync<object>(cnn, Row.FirstOrDefault, type, new CommandDefinition(sql, param, transaction, commandTimeout, commandType, CommandFlags.None, default(CancellationToken)));`
`133`	`133`	`}`
`134`	`134`	`/// <summary>`
`135`	`135`	`/// Execute a single-row query asynchronously using .NET 4.5 Task.`
`136`	`136`	`/// </summary>`
`137`	`137`	`public static Task<object> QuerySingleAsync(this IDbConnection cnn, Type type, string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null)`
`138`	`138`	`{`
`139`		`- if (type == null) throw new ArgumentNullException(nameof(type));`
	`139`	`+ if (type == null) throw new ArgumentNullException("type");`
`140`	`140`	`return QueryRowAsync<object>(cnn, Row.Single, type, new CommandDefinition(sql, param, transaction, commandTimeout, commandType, CommandFlags.None, default(CancellationToken)));`
`141`	`141`	`}`
`142`	`142`	`/// <summary>`
`143`	`143`	`/// Execute a single-row query asynchronously using .NET 4.5 Task.`
`144`	`144`	`/// </summary>`
`145`	`145`	`public static Task<object> QuerySingleOrDefaultAsync(this IDbConnection cnn, Type type, string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null)`
`146`	`146`	`{`
`147`		`- if (type == null) throw new ArgumentNullException(nameof(type));`
	`147`	`+ if (type == null) throw new ArgumentNullException("type");`
`148`	`148`	`return QueryRowAsync<object>(cnn, Row.SingleOrDefault, type, new CommandDefinition(sql, param, transaction, commandTimeout, commandType, CommandFlags.None, default(CancellationToken)));`
`149`	`149`	`}`
`150`	`150`
`@@ -205,7 +205,7 @@ private static Task<DbDataReader> ExecuteReaderWithFlagsFallbackAsync(DbCommand`
`205`	`205`	`private static async Task<IEnumerable<T>> QueryAsync<T>(this IDbConnection cnn, Type effectiveType, CommandDefinition command)`
`206`	`206`	`{`
`207`	`207`	`object param = command.Parameters;`
`208`		`- var identity = new Identity(command.CommandText, command.CommandType, cnn, effectiveType, param?.GetType(), null);`
	`208`	`+ var identity = new Identity(command.CommandText, command.CommandType, cnn, effectiveType, param != null ? param.GetType() : null, null);`
`209`	`209`	`var info = GetCacheInfo(identity, param, command.AddToCache);`
`210`	`210`	`bool wasClosed = cnn.State == ConnectionState.Closed;`
`211`	`211`	`var cancel = command.CancellationToken;`
`@@ -267,7 +267,7 @@ private static async Task<IEnumerable<T>> QueryAsync<T>(this IDbConnection cnn,`
`267`	`267`	`private static async Task<T> QueryRowAsync<T>(this IDbConnection cnn, Row row, Type effectiveType, CommandDefinition command)`
`268`	`268`	`{`
`269`	`269`	`object param = command.Parameters;`
`270`		`- var identity = new Identity(command.CommandText, command.CommandType, cnn, effectiveType, param?.GetType(), null);`
	`270`	`+ var identity = new Identity(command.CommandText, command.CommandType, cnn, effectiveType, param != null ? param.GetType() : null, null);`
`271`	`271`	`var info = GetCacheInfo(identity, param, command.AddToCache);`
`272`	`272`	`bool wasClosed = cnn.State == ConnectionState.Closed;`
`273`	`273`	`var cancel = command.CancellationToken;`
`@@ -452,7 +452,7 @@ private static async Task<int> ExecuteMultiImplAsync(IDbConnection cnn, CommandD`
`452`	`452`	`}`
`453`	`453`	`private static async Task<int> ExecuteImplAsync(IDbConnection cnn, CommandDefinition command, object param)`
`454`	`454`	`{`
`455`		`- var identity = new Identity(command.CommandText, command.CommandType, cnn, null, param?.GetType(), null);`
	`455`	`+ var identity = new Identity(command.CommandText, command.CommandType, cnn, null, param != null ? param.GetType() : null, null);`
`456`	`456`	`var info = GetCacheInfo(identity, param, command.AddToCache);`
`457`	`457`	`bool wasClosed = cnn.State == ConnectionState.Closed;`
`458`	`458`	`using (var cmd = (DbCommand)command.SetupCommand(cnn, info.ParamReader))`
`@@ -645,7 +645,7 @@ public static Task<IEnumerable<TReturn>> QueryAsync<TFirst, TSecond, TThird, TFo`
`645`	`645`	`private static async Task<IEnumerable<TReturn>> MultiMapAsync<TFirst, TSecond, TThird, TFourth, TFifth, TSixth, TSeventh, TReturn>(this IDbConnection cnn, CommandDefinition command, Delegate map, string splitOn)`
`646`	`646`	`{`
`647`	`647`	`object param = command.Parameters;`
`648`		`- var identity = new Identity(command.CommandText, command.CommandType, cnn, typeof(TFirst), param?.GetType(), new[] { typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh) });`
	`648`	`+ var identity = new Identity(command.CommandText, command.CommandType, cnn, typeof(TFirst), param != null ? param.GetType() : null, new[] { typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh) });`
`649`	`649`	`var info = GetCacheInfo(identity, param, command.AddToCache);`
`650`	`650`	`bool wasClosed = cnn.State == ConnectionState.Closed;`
`651`	`651`	`try`
`@@ -693,7 +693,7 @@ private static async Task<IEnumerable<TReturn>> MultiMapAsync<TReturn>(this IDbC`
`693`	`693`	`}`
`694`	`694`
`695`	`695`	`object param = command.Parameters;`
`696`		`- var identity = new Identity(command.CommandText, command.CommandType, cnn, types[0], param?.GetType(), types);`
	`696`	`+ var identity = new Identity(command.CommandText, command.CommandType, cnn, types[0], param != null ? param.GetType() : null, types);`
`697`	`697`	`var info = GetCacheInfo(identity, param, command.AddToCache);`
`698`	`698`	`bool wasClosed = cnn.State == ConnectionState.Closed;`
`699`	`699`	`try {`
`@@ -718,7 +718,8 @@ private static IEnumerable<T> ExecuteReaderSync<T>(IDataReader reader, Func<IDat`
`718`	`718`	`yield return (T)func(reader);`
`719`	`719`	`}`
`720`	`720`	`while (reader.NextResult()) { }`
`721`		`- (parameters as IParameterCallbacks)?.OnCompleted();`
	`721`	`+ var callbacks = parameters as IParameterCallbacks;`
	`722`	`+ if (callbacks != null) callbacks.OnCompleted();`
`722`	`723`	`}`
`723`	`724`	`}`
`724`	`725`
`@@ -739,7 +740,7 @@ public static Task<GridReader> QueryMultipleAsync(`
`739`	`740`	`public static async Task<GridReader> QueryMultipleAsync(this IDbConnection cnn, CommandDefinition command)`
`740`	`741`	`{`
`741`	`742`	`object param = command.Parameters;`
`742`		`- Identity identity = new Identity(command.CommandText, command.CommandType, cnn, typeof(GridReader), param?.GetType(), null);`
	`743`	`+ Identity identity = new Identity(command.CommandText, command.CommandType, cnn, typeof(GridReader), param != null ? param.GetType() : null, null);`
`743`	`744`	`CacheInfo info = GetCacheInfo(identity, param, command.AddToCache);`
`744`	`745`
`745`	`746`	`DbCommand cmd = null;`
`@@ -833,7 +834,7 @@ private static async Task<IDataReader> ExecuteReaderImplAsync(IDbConnection cnn,`
`833`	`834`	`finally`
`834`	`835`	`{`
`835`	`836`	`if (wasClosed) cnn.Close();`
`836`		`- cmd?.Dispose();`
	`837`	`+ if (cmd != null) cmd.Dispose();`
`837`	`838`	`}`
`838`	`839`	`}`
`839`	`840`
`@@ -903,7 +904,7 @@ private static async Task<T> ExecuteScalarImplAsync<T>(IDbConnection cnn, Comman`
`903`	`904`	`finally`
`904`	`905`	`{`
`905`	`906`	`if (wasClosed) cnn.Close();`
`906`		`- cmd?.Dispose();`
	`907`	`+ if (cmd != null) cmd.Dispose();`
`907`	`908`	`}`
`908`	`909`	`return Parse<T>(result);`
`909`	`910`	`}`
Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@ public Task<dynamic> ReadSingleOrDefaultAsync()`
`72`	`72`	`/// </summary>`
`73`	`73`	`public Task<IEnumerable<object>> ReadAsync(Type type, bool buffered = true)`
`74`	`74`	`{`
`75`		`- if (type == null) throw new ArgumentNullException(nameof(type));`
	`75`	`+ if (type == null) throw new ArgumentNullException("type");`
`76`	`76`	`return ReadAsyncImpl<object>(type, buffered);`
`77`	`77`	`}`
`78`	`78`
`@@ -81,31 +81,31 @@ public Task<IEnumerable<object>> ReadAsync(Type type, bool buffered = true)`
`81`	`81`	`/// </summary>`
`82`	`82`	`public Task<object> ReadFirstAsync(Type type)`
`83`	`83`	`{`
`84`		`- if (type == null) throw new ArgumentNullException(nameof(type));`
	`84`	`+ if (type == null) throw new ArgumentNullException("type");`
`85`	`85`	`return ReadRowAsyncImpl<object>(type, Row.First);`
`86`	`86`	`}`
`87`	`87`	`/// <summary>`
`88`	`88`	`/// Read an individual row of the next grid of results`
`89`	`89`	`/// </summary>`
`90`	`90`	`public Task<object> ReadFirstOrDefaultAsync(Type type)`
`91`	`91`	`{`
`92`		`- if (type == null) throw new ArgumentNullException(nameof(type));`
	`92`	`+ if (type == null) throw new ArgumentNullException("type");`
`93`	`93`	`return ReadRowAsyncImpl<object>(type, Row.FirstOrDefault);`
`94`	`94`	`}`
`95`	`95`	`/// <summary>`
`96`	`96`	`/// Read an individual row of the next grid of results`
`97`	`97`	`/// </summary>`
`98`	`98`	`public Task<object> ReadSingleAsync(Type type)`
`99`	`99`	`{`
`100`		`- if (type == null) throw new ArgumentNullException(nameof(type));`
	`100`	`+ if (type == null) throw new ArgumentNullException("type");`
`101`	`101`	`return ReadRowAsyncImpl<object>(type, Row.Single);`
`102`	`102`	`}`
`103`	`103`	`/// <summary>`
`104`	`104`	`/// Read an individual row of the next grid of results`
`105`	`105`	`/// </summary>`
`106`	`106`	`public Task<object> ReadSingleOrDefaultAsync(Type type)`
`107`	`107`	`{`
`108`		`- if (type == null) throw new ArgumentNullException(nameof(type));`
	`108`	`+ if (type == null) throw new ArgumentNullException("type");`
`109`	`109`	`return ReadRowAsyncImpl<object>(type, Row.SingleOrDefault);`
`110`	`110`	`}`
`111`	`111`
`@@ -160,7 +160,7 @@ private async Task NextResultAsync()`
`160`	`160`	`// need for "Cancel" etc`
`161`	`161`	`reader.Dispose();`
`162`	`162`	`reader = null;`
`163`		`- callbacks?.OnCompleted();`
	`163`	`+ if (callbacks != null) callbacks.OnCompleted();`
`164`	`164`	`Dispose();`
`165`	`165`	`}`
`166`	`166`	`}`
`@@ -234,23 +234,23 @@ private async Task<T> ReadRowAsyncImplViaDbReader<T>(DbDataReader reader, Type t`
`234`	`234`
`235`	`235`	`private async Task<IEnumerable<T>> ReadBufferedAsync<T>(int index, Func<IDataReader, object> deserializer, Identity typedIdentity)`
`236`	`236`	`{`
`237`		`- try`
`238`		`- {`
	`237`	`+ //try`
	`238`	`+ //{`
`239`	`239`	`var reader = (DbDataReader)this.reader;`
`240`	`240`	`List<T> buffer = new List<T>();`
`241`	`241`	`while (index == gridIndex && await reader.ReadAsync(cancel).ConfigureAwait(false))`
`242`	`242`	`{`
`243`	`243`	`buffer.Add((T)deserializer(reader));`
`244`	`244`	`}`
`245`	`245`	`return buffer;`
`246`		`- }`
`247`		`- finally // finally so that First etc progresses things even when multiple rows`
`248`		`- {`
`249`		`- if (index == gridIndex)`
`250`		`- {`
`251`		`- await NextResultAsync().ConfigureAwait(false);`
`252`		`- }`
`253`		`- }`
	`246`	`+ //}`
	`247`	`+ //finally // finally so that First etc progresses things even when multiple rows`
	`248`	`+ //{`
	`249`	`+ // if (index == gridIndex)`
	`250`	`+ // {`
	`251`	`+ // await NextResultAsync().ConfigureAwait(false);`
	`252`	`+ // }`
	`253`	`+ //}`
`254`	`254`	`}`
`255`	`255`	`}`
`256`	`256`