Make use of ConfigureAwait(false) consistent (graphql-dotnet#1263)

SimonCropp · joemcbride · commit 1dbe2a7e54b0 · 2019-08-20T17:30:10.000-07:00
diff --git a/src/GraphQL/DataLoader/BatchDataLoader.cs b/src/GraphQL/DataLoader/BatchDataLoader.cs
@@ -68,7 +68,7 @@ public async Task<T> LoadAsync(TKey key)
                 }
             }
 
-            var result = await DataLoaded;
+            var result = await DataLoaded.ConfigureAwait(false);
 
             if (result.TryGetValue(key, out T value))
             {
diff --git a/src/GraphQL/DataLoader/CollectionBatchDataLoader.cs b/src/GraphQL/DataLoader/CollectionBatchDataLoader.cs
@@ -60,7 +60,7 @@ public async Task<IEnumerable<T>> LoadAsync(TKey key)
                 }
             }
 
-            var result = await DataLoaded;
+            var result = await DataLoaded.ConfigureAwait(false);
 
             return result[key];
         }
diff --git a/src/GraphQL/Execution/SubscriptionExecutionStrategy.cs b/src/GraphQL/Execution/SubscriptionExecutionStrategy.cs
@@ -16,7 +16,7 @@ public override async Task<ExecutionResult> ExecuteAsync(ExecutionContext contex
             var rootType = GetOperationRootType(context.Document, context.Schema, context.Operation);
             var rootNode = BuildExecutionRootNode(context, rootType);
 
-            var streams = await ExecuteSubscriptionNodesAsync(context, rootNode.SubFields);
+            var streams = await ExecuteSubscriptionNodesAsync(context, rootNode.SubFields).ConfigureAwait(false);
 
             ExecutionResult result = new SubscriptionExecutionResult
             {
@@ -38,7 +38,7 @@ private async Task<IDictionary<string, IObservable<ExecutionResult>>> ExecuteSub
                 if (!(node.FieldDefinition is EventStreamFieldType fieldDefinition))
                     continue;
 
-                streams[name] = await ResolveEventStreamAsync(context, node);
+                streams[name] = await ResolveEventStreamAsync(context, node).ConfigureAwait(false);
             }
 
             return streams;
@@ -93,7 +93,7 @@ protected virtual async Task<IObservable<ExecutionResult>> ResolveEventStreamAsy
                 }
                 else if (eventStreamField?.AsyncSubscriber != null)
                 {
-                    subscription = await eventStreamField.AsyncSubscriber.SubscribeAsync(resolveContext);
+                    subscription = await eventStreamField.AsyncSubscriber.SubscribeAsync(resolveContext).ConfigureAwait(false);
                 }
                 else
                 {
diff --git a/src/GraphQL/Http/DocumentWriter.cs b/src/GraphQL/Http/DocumentWriter.cs
@@ -73,7 +73,7 @@ public static async Task<string> WriteToStringAsync<T>(this IDocumentWriter writ
         {
             using (var stream = new MemoryStream())
             {
-                await writer.WriteAsync(stream, value);
+                await writer.WriteAsync(stream, value).ConfigureAwait(false);
                 stream.Position = 0;
                 using (var reader = new StreamReader(stream, DocumentWriter.Utf8Encoding))
                 {
diff --git a/src/GraphQL/Http/HttpResponseStreamWriter.cs b/src/GraphQL/Http/HttpResponseStreamWriter.cs
@@ -161,7 +161,7 @@ public override async Task WriteAsync(char value)
 
             if (_charBufferCount == _charBufferSize)
             {
-                await FlushInternalAsync(flushEncoder: false);
+                await FlushInternalAsync(flushEncoder: false).ConfigureAwait(false);
             }
 
             _charBuffer[_charBufferCount] = value;
@@ -184,7 +184,7 @@ public override async Task WriteAsync(char[] values, int index, int count)
             {
                 if (_charBufferCount == _charBufferSize)
                 {
-                    await FlushInternalAsync(flushEncoder: false);
+                    await FlushInternalAsync(flushEncoder: false).ConfigureAwait(false);
                 }
 
                 CopyToCharBuffer(values, ref index, ref count);
@@ -209,7 +209,7 @@ public override async Task WriteAsync(string value)
             {
                 if (_charBufferCount == _charBufferSize)
                 {
-                    await FlushInternalAsync(flushEncoder: false);
+                    await FlushInternalAsync(flushEncoder: false).ConfigureAwait(false);
                 }
 
                 CopyToCharBuffer(value, ref index, ref count);
@@ -304,7 +304,7 @@ private async Task FlushInternalAsync(bool flushEncoder)
 
             if (count > 0)
             {
-                await _stream.WriteAsync(_byteBuffer, 0, count);
+                await _stream.WriteAsync(_byteBuffer, 0, count).ConfigureAwait(false);
             }
         }
 
diff --git a/src/GraphQL/Instrumentation/InstrumentFieldsMiddleware.cs b/src/GraphQL/Instrumentation/InstrumentFieldsMiddleware.cs
@@ -19,7 +19,7 @@ public async Task<object> Resolve(ResolveFieldContext context, FieldMiddlewareDe
 
             using (context.Metrics.Subject("field", context.FieldName, metadata))
             {
-                var result = await next(context);
+                var result = await next(context).ConfigureAwait(false);
                 return result;
             }
         }
diff --git a/src/GraphQL/Introspection/SchemaMetaFieldType.cs b/src/GraphQL/Introspection/SchemaMetaFieldType.cs
@@ -29,7 +29,7 @@ public __Schema()
                 "A list of all types supported by this server.",
                 resolve: async context =>
                 {
-                    return await context.Schema.AllTypes.WhereAsync(x => context.Schema.Filter.AllowType(x));
+                    return await context.Schema.AllTypes.WhereAsync(x => context.Schema.Filter.AllowType(x)).ConfigureAwait(false);
                 });
 
             Field<NonNullGraphType<__Type>>(
@@ -45,7 +45,7 @@ public __Schema()
                 "If this server supports mutation, the type that mutation operations will be rooted at.",
                 resolve: async context =>
                 {
-                    if (await context.Schema.Filter.AllowType(context.Schema.Mutation))
+                    if (await context.Schema.Filter.AllowType(context.Schema.Mutation).ConfigureAwait(false))
                     {
                         return context.Schema.Mutation;
                     }
@@ -57,7 +57,7 @@ public __Schema()
                 "If this server supports subscription, the type that subscription operations will be rooted at.",
                 resolve: async context =>
                 {
-                    if (await context.Schema.Filter.AllowType(context.Schema.Subscription))
+                    if (await context.Schema.Filter.AllowType(context.Schema.Subscription).ConfigureAwait(false))
                     {
                         return context.Schema.Subscription;
                     }
@@ -69,7 +69,7 @@ public __Schema()
                 "A list of all directives supported by this server.",
                 resolve: async context =>
                 {
-                    return await context.Schema.Directives.WhereAsync(d => context.Schema.Filter.AllowDirective(d));
+                    return await context.Schema.Directives.WhereAsync(d => context.Schema.Filter.AllowDirective(d)).ConfigureAwait(false);
                 });
         }
     }
diff --git a/src/GraphQL/Introspection/__Field.cs b/src/GraphQL/Introspection/__Field.cs
@@ -19,7 +19,7 @@ public __Field()
                 resolve: async context =>
                 {
                     var arguments = context.Source.Arguments ?? Enumerable.Empty<QueryArgument>();
-                    return await arguments.WhereAsync(x => context.Schema.Filter.AllowArgument(context.Source, x));
+                    return await arguments.WhereAsync(x => context.Schema.Filter.AllowArgument(context.Source, x)).ConfigureAwait(false);
                 });
             Field<NonNullGraphType<__Type>>("type", resolve: ctx => ctx.Source.ResolvedType);
             Field<NonNullGraphType<BooleanGraphType>>("isDeprecated", resolve: context =>
diff --git a/src/GraphQL/Introspection/__Type.cs b/src/GraphQL/Introspection/__Type.cs
@@ -50,7 +50,7 @@ public __Type()
                             : type?.Fields;
 
                         fields = fields ?? Enumerable.Empty<FieldType>();
-                        fields = await fields.WhereAsync(f => context.Schema.Filter.AllowField(context.Source as IGraphType, f));
+                        fields = await fields.WhereAsync(f => context.Schema.Filter.AllowField(context.Source as IGraphType, f)).ConfigureAwait(false);
 
                         return fields.OrderBy(f => f.Name);
                     }
@@ -60,13 +60,13 @@ public __Type()
             {
                 var type = context.Source as IImplementInterfaces;
                 if (type == null) return null;
-                return await type.ResolvedInterfaces.WhereAsync(x => context.Schema.Filter.AllowType(x));
+                return await type.ResolvedInterfaces.WhereAsync(x => context.Schema.Filter.AllowType(x)).ConfigureAwait(false);
             });
             FieldAsync<ListGraphType<NonNullGraphType<__Type>>>("possibleTypes", resolve: async context =>
             {
                 if (context.Source is IAbstractGraphType type)
                 {
-                    return await type.PossibleTypes.WhereAsync(x => context.Schema.Filter.AllowType(x));
+                    return await type.PossibleTypes.WhereAsync(x => context.Schema.Filter.AllowType(x)).ConfigureAwait(false);
                 }
 
                 return null;
@@ -86,7 +86,7 @@ public __Type()
                             ? type.Values.Where(e => string.IsNullOrWhiteSpace(e.DeprecationReason)).ToList()
                             : type.Values.ToList();
 
-                        return await values.WhereAsync(v => context.Schema.Filter.AllowEnumValue(type, v));
+                        return await values.WhereAsync(v => context.Schema.Filter.AllowEnumValue(type, v)).ConfigureAwait(false);
                     }
 
                     return null;
@@ -95,7 +95,7 @@ public __Type()
             {
                 var type = context.Source as IInputObjectGraphType;
                 if (type == null) return null;
-                return await type.Fields.WhereAsync(f => context.Schema.Filter.AllowField(type, f));
+                return await type.Fields.WhereAsync(f => context.Schema.Filter.AllowField(type, f)).ConfigureAwait(false);
             });
             Field<__Type>("ofType", resolve: context =>
             {
diff --git a/src/GraphQL/Resolvers/AsyncEventStreamResolver.cs b/src/GraphQL/Resolvers/AsyncEventStreamResolver.cs
@@ -23,7 +23,7 @@ public Task<IObservable<T>> SubscribeAsync(ResolveEventStreamContext context)
 
         async Task<IObservable<object>> IAsyncEventStreamResolver.SubscribeAsync(ResolveEventStreamContext context)
         {
-            var result = await SubscribeAsync(context);
+            var result = await SubscribeAsync(context).ConfigureAwait(false);
             return (IObservable<object>)result;
         }
     }
@@ -45,7 +45,7 @@ public Task<IObservable<TReturnType>> SubscribeAsync(ResolveEventStreamContext c
 
         async Task<IObservable<object>> IAsyncEventStreamResolver.SubscribeAsync(ResolveEventStreamContext context)
         {
-            var result = await SubscribeAsync(context);
+            var result = await SubscribeAsync(context).ConfigureAwait(false);
             return (IObservable<object>)result;
         }
     }
@@ -73,7 +73,7 @@ async Task<IObservable<object>> IAsyncEventStreamResolver.SubscribeAsync(Resolve
                 throw new ArgumentException($"Return type of {_accessor.FieldName} should be Task<IObservable<T>>, instead of {_accessor.ReturnType}");
             }
 
-            await task;
+            await task.ConfigureAwait(false);
 
             return ((dynamic)task).Result;
         }
diff --git a/src/GraphQL/SchemaExtensions.cs b/src/GraphQL/SchemaExtensions.cs
@@ -1,4 +1,4 @@
-﻿using System;
+using System;
 using System.Threading.Tasks;
 using GraphQL.Http;
 using GraphQL.Types;
@@ -25,7 +25,7 @@ public static async Task<string> ExecuteAsync(this ISchema schema, Action<Execut
             {
                 _.Schema = schema;
                 configure(_);
-            });
+            }).ConfigureAwait(false);
             return new DocumentWriter(indent: true).Write(result);
         }
     }
diff --git a/src/GraphQL/TaskExtensions.cs b/src/GraphQL/TaskExtensions.cs
@@ -50,7 +50,7 @@ internal static async Task<IEnumerable<T>> WhereAsync<T>(this IEnumerable<T> ite
             }
 
             var itemTaskList = items.Select(item => new { Item = item, PredTask = predicate.Invoke(item) }).ToList();
-            await Task.WhenAll(itemTaskList.Select(x => x.PredTask));
+            await Task.WhenAll(itemTaskList.Select(x => x.PredTask)).ConfigureAwait(false);
             return itemTaskList.Where(x => x.PredTask.Result).Select(x => x.Item);
         }
     }
diff --git a/src/GraphQL/Types/ResolveFieldContext.cs b/src/GraphQL/Types/ResolveFieldContext.cs
@@ -115,7 +115,7 @@ public async Task<TResult> TryAsyncResolve<TResult>(Func<ResolveFieldContext<TSo
         {
             try
             {
-                return await resolve(this);
+                return await resolve(this).ConfigureAwait(false);
             }
             catch (Exception ex)
             {
@@ -130,7 +130,7 @@ public async Task<TResult> TryAsyncResolve<TResult>(Func<ResolveFieldContext<TSo
                 else
                 {
                     var result = error(Errors);
-                    return result == null ? default : await result;
+                    return result == null ? default : await result.ConfigureAwait(false);
                 }
             }
         }
diff --git a/src/GraphQL/Utilities/Federation/FederatedSchemaBuilder.cs b/src/GraphQL/Utilities/Federation/FederatedSchemaBuilder.cs
@@ -96,7 +96,7 @@ private void AddRootEntityFields(ISchema schema)
                                     Arguments = rep,
                                     ParentFieldContext = context
                                 };
-                                var result = await resolver.Resolve(resolveContext);
+                                var result = await resolver.Resolve(resolveContext).ConfigureAwait(false);
                                 results.Add(result);
                             }
                             else
diff --git a/src/GraphQL/Utilities/Federation/FuncFederatedResolver.cs b/src/GraphQL/Utilities/Federation/FuncFederatedResolver.cs
@@ -14,7 +14,7 @@ public FuncFederatedResolver(Func<FederatedResolveContext, Task<T>> func)
 
         public async Task<object> Resolve(FederatedResolveContext context)
         {
-            return await _resolver(context);
+            return await _resolver(context).ConfigureAwait(false);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ public async Task<T> LoadAsync(TKey key)`
`68`	`68`	`}`
`69`	`69`	`}`
`70`	`70`
`71`		`- var result = await DataLoaded;`
	`71`	`+ var result = await DataLoaded.ConfigureAwait(false);`
`72`	`72`
`73`	`73`	`if (result.TryGetValue(key, out T value))`
`74`	`74`	`{`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ public async Task<IEnumerable<T>> LoadAsync(TKey key)`
`60`	`60`	`}`
`61`	`61`	`}`
`62`	`62`
`63`		`- var result = await DataLoaded;`
	`63`	`+ var result = await DataLoaded.ConfigureAwait(false);`
`64`	`64`
`65`	`65`	`return result[key];`
`66`	`66`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ public override async Task<ExecutionResult> ExecuteAsync(ExecutionContext contex`
`16`	`16`	`var rootType = GetOperationRootType(context.Document, context.Schema, context.Operation);`
`17`	`17`	`var rootNode = BuildExecutionRootNode(context, rootType);`
`18`	`18`
`19`		`- var streams = await ExecuteSubscriptionNodesAsync(context, rootNode.SubFields);`
	`19`	`+ var streams = await ExecuteSubscriptionNodesAsync(context, rootNode.SubFields).ConfigureAwait(false);`
`20`	`20`
`21`	`21`	`ExecutionResult result = new SubscriptionExecutionResult`
`22`	`22`	`{`
`@@ -38,7 +38,7 @@ private async Task<IDictionary<string, IObservable<ExecutionResult>>> ExecuteSub`
`38`	`38`	`if (!(node.FieldDefinition is EventStreamFieldType fieldDefinition))`
`39`	`39`	`continue;`
`40`	`40`
`41`		`- streams[name] = await ResolveEventStreamAsync(context, node);`
	`41`	`+ streams[name] = await ResolveEventStreamAsync(context, node).ConfigureAwait(false);`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`return streams;`
`@@ -93,7 +93,7 @@ protected virtual async Task<IObservable<ExecutionResult>> ResolveEventStreamAsy`
`93`	`93`	`}`
`94`	`94`	`else if (eventStreamField?.AsyncSubscriber != null)`
`95`	`95`	`{`
`96`		`- subscription = await eventStreamField.AsyncSubscriber.SubscribeAsync(resolveContext);`
	`96`	`+ subscription = await eventStreamField.AsyncSubscriber.SubscribeAsync(resolveContext).ConfigureAwait(false);`
`97`	`97`	`}`
`98`	`98`	`else`
`99`	`99`	`{`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ public static async Task<string> WriteToStringAsync<T>(this IDocumentWriter writ`
`73`	`73`	`{`
`74`	`74`	`using (var stream = new MemoryStream())`
`75`	`75`	`{`
`76`		`- await writer.WriteAsync(stream, value);`
	`76`	`+ await writer.WriteAsync(stream, value).ConfigureAwait(false);`
`77`	`77`	`stream.Position = 0;`
`78`	`78`	`using (var reader = new StreamReader(stream, DocumentWriter.Utf8Encoding))`
`79`	`79`	`{`
Original file line number	Diff line number	Diff line change
`@@ -161,7 +161,7 @@ public override async Task WriteAsync(char value)`
`161`	`161`
`162`	`162`	`if (_charBufferCount == _charBufferSize)`
`163`	`163`	`{`
`164`		`- await FlushInternalAsync(flushEncoder: false);`
	`164`	`+ await FlushInternalAsync(flushEncoder: false).ConfigureAwait(false);`
`165`	`165`	`}`
`166`	`166`
`167`	`167`	`_charBuffer[_charBufferCount] = value;`
`@@ -184,7 +184,7 @@ public override async Task WriteAsync(char[] values, int index, int count)`
`184`	`184`	`{`
`185`	`185`	`if (_charBufferCount == _charBufferSize)`
`186`	`186`	`{`
`187`		`- await FlushInternalAsync(flushEncoder: false);`
	`187`	`+ await FlushInternalAsync(flushEncoder: false).ConfigureAwait(false);`
`188`	`188`	`}`
`189`	`189`
`190`	`190`	`CopyToCharBuffer(values, ref index, ref count);`
`@@ -209,7 +209,7 @@ public override async Task WriteAsync(string value)`
`209`	`209`	`{`
`210`	`210`	`if (_charBufferCount == _charBufferSize)`
`211`	`211`	`{`
`212`		`- await FlushInternalAsync(flushEncoder: false);`
	`212`	`+ await FlushInternalAsync(flushEncoder: false).ConfigureAwait(false);`
`213`	`213`	`}`
`214`	`214`
`215`	`215`	`CopyToCharBuffer(value, ref index, ref count);`
`@@ -304,7 +304,7 @@ private async Task FlushInternalAsync(bool flushEncoder)`
`304`	`304`
`305`	`305`	`if (count > 0)`
`306`	`306`	`{`
`307`		`- await _stream.WriteAsync(_byteBuffer, 0, count);`
	`307`	`+ await _stream.WriteAsync(_byteBuffer, 0, count).ConfigureAwait(false);`
`308`	`308`	`}`
`309`	`309`	`}`
`310`	`310`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ public async Task<object> Resolve(ResolveFieldContext context, FieldMiddlewareDe`
`19`	`19`
`20`	`20`	`using (context.Metrics.Subject("field", context.FieldName, metadata))`
`21`	`21`	`{`
`22`		`- var result = await next(context);`
	`22`	`+ var result = await next(context).ConfigureAwait(false);`
`23`	`23`	`return result;`
`24`	`24`	`}`
`25`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ public __Schema()`
`29`	`29`	`"A list of all types supported by this server.",`
`30`	`30`	`resolve: async context =>`
`31`	`31`	`{`
`32`		`- return await context.Schema.AllTypes.WhereAsync(x => context.Schema.Filter.AllowType(x));`
	`32`	`+ return await context.Schema.AllTypes.WhereAsync(x => context.Schema.Filter.AllowType(x)).ConfigureAwait(false);`
`33`	`33`	`});`
`34`	`34`
`35`	`35`	`Field<NonNullGraphType<__Type>>(`
`@@ -45,7 +45,7 @@ public __Schema()`
`45`	`45`	`"If this server supports mutation, the type that mutation operations will be rooted at.",`
`46`	`46`	`resolve: async context =>`
`47`	`47`	`{`
`48`		`- if (await context.Schema.Filter.AllowType(context.Schema.Mutation))`
	`48`	`+ if (await context.Schema.Filter.AllowType(context.Schema.Mutation).ConfigureAwait(false))`
`49`	`49`	`{`
`50`	`50`	`return context.Schema.Mutation;`
`51`	`51`	`}`
`@@ -57,7 +57,7 @@ public __Schema()`
`57`	`57`	`"If this server supports subscription, the type that subscription operations will be rooted at.",`
`58`	`58`	`resolve: async context =>`
`59`	`59`	`{`
`60`		`- if (await context.Schema.Filter.AllowType(context.Schema.Subscription))`
	`60`	`+ if (await context.Schema.Filter.AllowType(context.Schema.Subscription).ConfigureAwait(false))`
`61`	`61`	`{`
`62`	`62`	`return context.Schema.Subscription;`
`63`	`63`	`}`
`@@ -69,7 +69,7 @@ public __Schema()`
`69`	`69`	`"A list of all directives supported by this server.",`
`70`	`70`	`resolve: async context =>`
`71`	`71`	`{`
`72`		`- return await context.Schema.Directives.WhereAsync(d => context.Schema.Filter.AllowDirective(d));`
	`72`	`+ return await context.Schema.Directives.WhereAsync(d => context.Schema.Filter.AllowDirective(d)).ConfigureAwait(false);`
`73`	`73`	`});`
`74`	`74`	`}`
`75`	`75`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ public __Field()`
`19`	`19`	`resolve: async context =>`
`20`	`20`	`{`
`21`	`21`	`var arguments = context.Source.Arguments ?? Enumerable.Empty<QueryArgument>();`
`22`		`- return await arguments.WhereAsync(x => context.Schema.Filter.AllowArgument(context.Source, x));`
	`22`	`+ return await arguments.WhereAsync(x => context.Schema.Filter.AllowArgument(context.Source, x)).ConfigureAwait(false);`
`23`	`23`	`});`
`24`	`24`	`Field<NonNullGraphType<__Type>>("type", resolve: ctx => ctx.Source.ResolvedType);`
`25`	`25`	`Field<NonNullGraphType<BooleanGraphType>>("isDeprecated", resolve: context =>`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ public __Type()`
`50`	`50`	`: type?.Fields;`
`51`	`51`
`52`	`52`	`fields = fields ?? Enumerable.Empty<FieldType>();`
`53`		`- fields = await fields.WhereAsync(f => context.Schema.Filter.AllowField(context.Source as IGraphType, f));`
	`53`	`+ fields = await fields.WhereAsync(f => context.Schema.Filter.AllowField(context.Source as IGraphType, f)).ConfigureAwait(false);`
`54`	`54`
`55`	`55`	`return fields.OrderBy(f => f.Name);`
`56`	`56`	`}`
`@@ -60,13 +60,13 @@ public __Type()`
`60`	`60`	`{`
`61`	`61`	`var type = context.Source as IImplementInterfaces;`
`62`	`62`	`if (type == null) return null;`
`63`		`- return await type.ResolvedInterfaces.WhereAsync(x => context.Schema.Filter.AllowType(x));`
	`63`	`+ return await type.ResolvedInterfaces.WhereAsync(x => context.Schema.Filter.AllowType(x)).ConfigureAwait(false);`
`64`	`64`	`});`
`65`	`65`	`FieldAsync<ListGraphType<NonNullGraphType<__Type>>>("possibleTypes", resolve: async context =>`
`66`	`66`	`{`
`67`	`67`	`if (context.Source is IAbstractGraphType type)`
`68`	`68`	`{`
`69`		`- return await type.PossibleTypes.WhereAsync(x => context.Schema.Filter.AllowType(x));`
	`69`	`+ return await type.PossibleTypes.WhereAsync(x => context.Schema.Filter.AllowType(x)).ConfigureAwait(false);`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`return null;`
`@@ -86,7 +86,7 @@ public __Type()`
`86`	`86`	`? type.Values.Where(e => string.IsNullOrWhiteSpace(e.DeprecationReason)).ToList()`
`87`	`87`	`: type.Values.ToList();`
`88`	`88`
`89`		`- return await values.WhereAsync(v => context.Schema.Filter.AllowEnumValue(type, v));`
	`89`	`+ return await values.WhereAsync(v => context.Schema.Filter.AllowEnumValue(type, v)).ConfigureAwait(false);`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`return null;`
`@@ -95,7 +95,7 @@ public __Type()`
`95`	`95`	`{`
`96`	`96`	`var type = context.Source as IInputObjectGraphType;`
`97`	`97`	`if (type == null) return null;`
`98`		`- return await type.Fields.WhereAsync(f => context.Schema.Filter.AllowField(type, f));`
	`98`	`+ return await type.Fields.WhereAsync(f => context.Schema.Filter.AllowField(type, f)).ConfigureAwait(false);`
`99`	`99`	`});`
`100`	`100`	`Field<__Type>("ofType", resolve: context =>`
`101`	`101`	`{`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ public Task<IObservable<T>> SubscribeAsync(ResolveEventStreamContext context)`
`23`	`23`
`24`	`24`	`async Task<IObservable<object>> IAsyncEventStreamResolver.SubscribeAsync(ResolveEventStreamContext context)`
`25`	`25`	`{`
`26`		`- var result = await SubscribeAsync(context);`
	`26`	`+ var result = await SubscribeAsync(context).ConfigureAwait(false);`
`27`	`27`	`return (IObservable<object>)result;`
`28`	`28`	`}`
`29`	`29`	`}`
`@@ -45,7 +45,7 @@ public Task<IObservable<TReturnType>> SubscribeAsync(ResolveEventStreamContext c`
`45`	`45`
`46`	`46`	`async Task<IObservable<object>> IAsyncEventStreamResolver.SubscribeAsync(ResolveEventStreamContext context)`
`47`	`47`	`{`
`48`		`- var result = await SubscribeAsync(context);`
	`48`	`+ var result = await SubscribeAsync(context).ConfigureAwait(false);`
`49`	`49`	`return (IObservable<object>)result;`
`50`	`50`	`}`
`51`	`51`	`}`
`@@ -73,7 +73,7 @@ async Task<IObservable<object>> IAsyncEventStreamResolver.SubscribeAsync(Resolve`
`73`	`73`	`throw new ArgumentException($"Return type of {_accessor.FieldName} should be Task<IObservable<T>>, instead of {_accessor.ReturnType}");`
`74`	`74`	`}`
`75`	`75`
`76`		`- await task;`
	`76`	`+ await task.ConfigureAwait(false);`
`77`	`77`
`78`	`78`	`return ((dynamic)task).Result;`
`79`	`79`	`}`