Add missing ConfigureAwait calls (#2477)

rayokota · web-flow · commit ae744d803fbb · 2025-05-22T18:52:55.000-07:00
* Add missing ConfigureAwait calls

* Minor fix
diff --git a/src/Confluent.SchemaRegistry.Rules/CelExecutor.cs b/src/Confluent.SchemaRegistry.Rules/CelExecutor.cs
@@ -44,7 +44,8 @@ public void Configure(IEnumerable<KeyValuePair<string, string>> config,
 
         public async Task<object> Transform(RuleContext ctx, object message)
         {
-            return await Execute(ctx, message, new Dictionary<string, object>() { { "message", message } });
+            return await Execute(ctx, message, new Dictionary<string, object>() { { "message", message } })
+                .ConfigureAwait(false);
         }
 
         public async Task<object> Execute(RuleContext ctx, object obj, IDictionary<string, object> args)
@@ -59,7 +60,7 @@ public async Task<object> Execute(RuleContext ctx, object obj, IDictionary<strin
                     object guardResult = false;
                     try
                     {
-                        guardResult = await Execute(ctx, guard, obj, args);
+                        guardResult = await Execute(ctx, guard, obj, args).ConfigureAwait(false);
                     }
                     catch (RuleException e)
                     {
@@ -75,7 +76,7 @@ public async Task<object> Execute(RuleContext ctx, object obj, IDictionary<strin
                 expr = expr.Substring(index + 1);
             }
 
-            return await Execute(ctx, expr, obj, args);
+            return await Execute(ctx, expr, obj, args).ConfigureAwait(false);
         }
 
         private async Task<object> Execute(RuleContext ctx, string rule, object obj, IDictionary<string, object> args)
diff --git a/src/Confluent.SchemaRegistry.Rules/CelFieldExecutor.cs b/src/Confluent.SchemaRegistry.Rules/CelFieldExecutor.cs
@@ -69,7 +69,7 @@ public async Task<object> Transform(RuleContext ctx, RuleContext.FieldContext fi
                         { "tags", fieldCtx.Tags.ToList() },
                         { "message", message }
                     }
-                );
+                ).ConfigureAwait(false);
                 if (result is ByteString)
                 {
                     result = ((ByteString)result).ToByteArray();
diff --git a/src/Confluent.SchemaRegistry.Serdes.Avro/GenericDeserializerImpl.cs b/src/Confluent.SchemaRegistry.Serdes.Avro/GenericDeserializerImpl.cs
@@ -56,7 +56,7 @@ public override async Task<GenericRecord> DeserializeAsync(ReadOnlyMemory<byte>
             return isNull
                 ? default
                 : await Deserialize(context.Topic, context.Headers, data.ToArray(),
-                    context.Component == MessageComponentType.Key);
+                    context.Component == MessageComponentType.Key).ConfigureAwait(false);
         }
         
         public async Task<GenericRecord> Deserialize(string topic, Headers headers, byte[] array, bool isKey)
@@ -85,7 +85,7 @@ public async Task<GenericRecord> Deserialize(string topic, Headers headers, byte
                 SchemaId writerId = new SchemaId(SchemaType.Avro);
                 using (var stream = schemaIdDeserializer.Deserialize(array, context, ref writerId))
                 {
-                    (writerSchemaJson, writerSchema) = await GetWriterSchema(subject, writerId);
+                    (writerSchemaJson, writerSchema) = await GetWriterSchema(subject, writerId).ConfigureAwait(false);
                     if (subject == null)
                     {
                         subject = GetSubjectName(topic, isKey, writerSchema.Fullname);
@@ -126,7 +126,7 @@ public async Task<GenericRecord> Deserialize(string topic, Headers headers, byte
                             .ContinueWith(t => (JToken)t.Result)
                             .ConfigureAwait(continueOnCapturedContext: false);
                         readerSchemaJson = latestSchema;
-                        readerSchema = await GetParsedSchema(readerSchemaJson);
+                        readerSchema = await GetParsedSchema(readerSchemaJson).ConfigureAwait(false);
                         Avro.IO.Decoder decoder = new JsonDecoder(readerSchema, json.ToString(Formatting.None));
 
                         datumReader = new GenericReader<GenericRecord>(readerSchema, readerSchema);
@@ -137,14 +137,14 @@ public async Task<GenericRecord> Deserialize(string topic, Headers headers, byte
                         if (latestSchema != null)
                         {
                             readerSchemaJson = latestSchema;
-                            readerSchema = await GetParsedSchema(readerSchemaJson);
+                            readerSchema = await GetParsedSchema(readerSchemaJson).ConfigureAwait(false);
                         }
                         else
                         {
                             readerSchemaJson = writerSchemaJson;
                             readerSchema = writerSchema;
                         }
-                        datumReader = await GetDatumReader(writerSchema, readerSchema);
+                        datumReader = await GetDatumReader(writerSchema, readerSchema).ConfigureAwait(false);
                         data = datumReader.Read(default(GenericRecord), new BinaryDecoder(stream));
                     }
                 }
diff --git a/src/Confluent.SchemaRegistry.Serdes.Avro/GenericSerializerImpl.cs b/src/Confluent.SchemaRegistry.Serdes.Avro/GenericSerializerImpl.cs
@@ -162,7 +162,7 @@ public async Task<byte[]> Serialize(string topic, Headers headers, GenericRecord
 
                 if (latestSchema != null)
                 {
-                    writerSchema = await GetParsedSchema(latestSchema);
+                    writerSchema = await GetParsedSchema(latestSchema).ConfigureAwait(false);
                     FieldTransformer fieldTransformer = async (ctx, transform, message) => 
                     {
                         return await AvroUtils.Transform(ctx, writerSchema, message, transform).ConfigureAwait(false);
diff --git a/src/Confluent.SchemaRegistry.Serdes.Avro/SpecificDeserializerImpl.cs b/src/Confluent.SchemaRegistry.Serdes.Avro/SpecificDeserializerImpl.cs
@@ -107,7 +107,7 @@ public override async Task<T> DeserializeAsync(ReadOnlyMemory<byte> data, bool i
             return isNull
                 ? default
                 : await Deserialize(context.Topic, context.Headers, data.ToArray(),
-                    context.Component == MessageComponentType.Key);
+                    context.Component == MessageComponentType.Key).ConfigureAwait(false);
         }
         
         public async Task<T> Deserialize(string topic, Headers headers, byte[] array, bool isKey)
@@ -134,7 +134,7 @@ public async Task<T> Deserialize(string topic, Headers headers, byte[] array, bo
                 SchemaId writerId = new SchemaId(SchemaType.Avro);
                 using (var stream = schemaIdDeserializer.Deserialize(array, context, ref writerId))
                 {
-                    (writerSchemaJson, writerSchema) = await GetWriterSchema(subject, writerId);
+                    (writerSchemaJson, writerSchema) = await GetWriterSchema(subject, writerId).ConfigureAwait(false);
                     if (subject == null)
                     {
                         subject = GetSubjectName(topic, isKey, writerSchema.Fullname);
@@ -181,13 +181,15 @@ public async Task<T> Deserialize(string topic, Headers headers, byte[] array, bo
                     }
                     else
                     {
-                        datumReader = await GetDatumReader(writerSchema, ReaderSchema);
+                        datumReader = await GetDatumReader(writerSchema, ReaderSchema).ConfigureAwait(false);
                         data = Read(datumReader, new BinaryDecoder(stream));
                     }
                 }
 
                 Schema readerSchemaJson = latestSchema ?? writerSchemaJson;
-                Avro.Schema readerSchema = latestSchema != null ? await GetParsedSchema(latestSchema) : writerSchema;
+                Avro.Schema readerSchema = latestSchema != null
+                    ? await GetParsedSchema(latestSchema).ConfigureAwait(false)
+                    : writerSchema;
                 FieldTransformer fieldTransformer = async (ctx, transform, message) =>
                 {
                     return await AvroUtils.Transform(ctx, readerSchema, message, transform).ConfigureAwait(false);
diff --git a/src/Confluent.SchemaRegistry.Serdes.Avro/SpecificSerializerImpl.cs b/src/Confluent.SchemaRegistry.Serdes.Avro/SpecificSerializerImpl.cs
@@ -204,7 +204,7 @@ public async Task<byte[]> Serialize(string topic, Headers headers, T data, bool
 
                 if (latestSchema != null)
                 {
-                    var schema = await GetParsedSchema(latestSchema);
+                    var schema = await GetParsedSchema(latestSchema).ConfigureAwait(false);
                     FieldTransformer fieldTransformer = async (ctx, transform, message) => 
                     {
                         return await AvroUtils.Transform(ctx, schema, message, transform).ConfigureAwait(false);
diff --git a/src/Confluent.SchemaRegistry.Serdes.Json/JsonDeserializer.cs b/src/Confluent.SchemaRegistry.Serdes.Json/JsonDeserializer.cs
@@ -193,7 +193,8 @@ public override async Task<T> DeserializeAsync(ReadOnlyMemory<byte> data, bool i
                 {
                     if (schemaRegistryClient != null)
                     {
-                        (writerSchemaJson, writerSchema) = await GetWriterSchema(subject, writerId);
+                        (writerSchemaJson, writerSchema) = await GetWriterSchema(subject, writerId)
+                            .ConfigureAwait(false);
                         if (subject == null)
                         {
                             subject = GetSubjectName(topic, isKey, writerSchema.Title);
@@ -210,7 +211,7 @@ public override async Task<T> DeserializeAsync(ReadOnlyMemory<byte> data, bool i
                         migrations = await GetMigrations(subject, writerSchemaJson, latestSchema)
                             .ConfigureAwait(continueOnCapturedContext: false);
                         readerSchemaJson = latestSchema;
-                        readerSchema = await GetParsedSchema(latestSchema);
+                        readerSchema = await GetParsedSchema(latestSchema).ConfigureAwait(false);
                     }
                     else if (schema != null)
                     {
@@ -296,7 +297,7 @@ protected override async Task<JsonSchema> ParseSchema(Schema schema)
             JsonSchemaResolver utils = new JsonSchemaResolver(
                 schemaRegistryClient, schema, jsonSchemaGeneratorSettings);
             
-            return await utils.GetResolvedSchema();
+            return await utils.GetResolvedSchema().ConfigureAwait(false);
         }
     }
 }
diff --git a/src/Confluent.SchemaRegistry.Serdes.Json/JsonSchemaResolver.cs b/src/Confluent.SchemaRegistry.Serdes.Json/JsonSchemaResolver.cs
@@ -79,8 +79,8 @@ public JsonSchemaResolver(ISchemaRegistryClient schemaRegistryClient, Schema sch
         public async Task<JsonSchema> GetResolvedSchema(){
             if (resolvedJsonSchema == null)
             {
-                await CreateSchemaDictUtil(root);
-                resolvedJsonSchema = await GetSchemaUtil(root);
+                await CreateSchemaDictUtil(root).ConfigureAwait(false);
+                resolvedJsonSchema = await GetSchemaUtil(root).ConfigureAwait(false);
             }
             return resolvedJsonSchema;
         }
@@ -94,8 +94,9 @@ private async Task CreateSchemaDictUtil(Schema root, string referenceName = null
             {
                 foreach (var reference in root.References)
                 {
-                    Schema refSchemaRes = await schemaRegistryClient.GetRegisteredSchemaAsync(reference.Subject, reference.Version, false);
-                    await CreateSchemaDictUtil(refSchemaRes, reference.Name);
+                    Schema refSchemaRes = await schemaRegistryClient.GetRegisteredSchemaAsync(reference.Subject, reference.Version, false)
+                        .ConfigureAwait(false);
+                    await CreateSchemaDictUtil(refSchemaRes, reference.Name).ConfigureAwait(false);
                 }
             }
         }
@@ -107,7 +108,7 @@ private async Task<JsonSchema> GetSchemaUtil(Schema root)
             {
                 if (!dictSchemaNameToJsonSchema.ContainsKey(x.Name))
                 {
-                    var jsonSchema = await GetSchemaUtil(dictSchemaNameToSchema[x.Name]);
+                    var jsonSchema = await GetSchemaUtil(dictSchemaNameToSchema[x.Name]).ConfigureAwait(false);
                     dictSchemaNameToJsonSchema.Add(x.Name, jsonSchema);
                 }
             }
@@ -125,7 +126,7 @@ private async Task<JsonSchema> GetSchemaUtil(Schema root)
             string rootStr = root.SchemaString;
             JObject schema = JObject.Parse(rootStr);
             string schemaId = (string)schema["$id"] ?? "";
-            return await JsonSchema.FromJsonAsync(rootStr, schemaId, factory);
+            return await JsonSchema.FromJsonAsync(rootStr, schemaId, factory).ConfigureAwait(false);
         }
 
         private class CustomJsonReferenceResolver : JsonReferenceResolver
@@ -163,7 +164,7 @@ public override async Task<IJsonReference> ResolveFileReferenceAsync(string file
                     return schema;
                 }
 
-                return await base.ResolveFileReferenceAsync(filePath, cancellationToken);
+                return await base.ResolveFileReferenceAsync(filePath, cancellationToken).ConfigureAwait(false);
             }
 
             public override async Task<IJsonReference> ResolveUrlReferenceAsync(string url, CancellationToken cancellationToken = default)
@@ -189,7 +190,7 @@ public override async Task<IJsonReference> ResolveUrlReferenceAsync(string url,
                     }
                 }
 
-                return await base.ResolveUrlReferenceAsync(url, cancellationToken);
+                return await base.ResolveUrlReferenceAsync(url, cancellationToken).ConfigureAwait(false);
             }
         }
     }
diff --git a/src/Confluent.SchemaRegistry.Serdes.Json/JsonSerializer.cs b/src/Confluent.SchemaRegistry.Serdes.Json/JsonSerializer.cs
@@ -282,7 +282,7 @@ protected override async Task<JsonSchema> ParseSchema(Schema schema)
         {
             JsonSchemaResolver utils = new JsonSchemaResolver(
                 schemaRegistryClient, schema, jsonSchemaGeneratorSettings);
-            return await utils.GetResolvedSchema();
+            return await utils.GetResolvedSchema().ConfigureAwait(false);
         }
     }
 }
diff --git a/src/Confluent.SchemaRegistry.Serdes.Protobuf/ProtobufDeserializer.cs b/src/Confluent.SchemaRegistry.Serdes.Protobuf/ProtobufDeserializer.cs
@@ -136,7 +136,7 @@ public override async Task<T> DeserializeAsync(ReadOnlyMemory<byte> data, bool i
                 {
                     if (schemaRegistryClient != null)
                     {
-                        (writerSchema, fdSet) = await GetWriterSchema(subject, writerId);
+                        (writerSchema, fdSet) = await GetWriterSchema(subject, writerId).ConfigureAwait(false);
                     }
 
                     message = parser.ParseFrom(stream);
diff --git a/src/Confluent.SchemaRegistry/AsyncSerde.cs b/src/Confluent.SchemaRegistry/AsyncSerde.cs
@@ -96,14 +96,14 @@ protected string GetSubjectName(string topic, bool isKey, string recordType)
             {
                 Schema writerSchema = await schemaRegistryClient.GetSchemaBySubjectAndIdAsync(subject, writerId.Id ?? 0, format)
                     .ConfigureAwait(continueOnCapturedContext: false);
-                TParsedSchema parsedSchema = await GetParsedSchema(writerSchema);
+                TParsedSchema parsedSchema = await GetParsedSchema(writerSchema).ConfigureAwait(false);
                 return (writerSchema, parsedSchema);
             }
             else if (writerId.Guid != null)
             {
                 Schema writerSchema = await schemaRegistryClient.GetSchemaByGuidAsync(writerId.Guid.ToString(), format)
                     .ConfigureAwait(continueOnCapturedContext: false);
-                TParsedSchema parsedSchema = await GetParsedSchema(writerSchema);
+                TParsedSchema parsedSchema = await GetParsedSchema(writerSchema).ConfigureAwait(false);
                 return (writerSchema, parsedSchema);
             }
             else
@@ -277,7 +277,7 @@ protected async Task<RegisteredSchema> GetReaderSchema(string subject, Schema sc
             if (useSchemaId >= 0)
             {
                 var schemaForId =
-                    await schemaRegistryClient.GetSchemaBySubjectAndIdAsync(subject, useSchemaId);
+                    await schemaRegistryClient.GetSchemaBySubjectAndIdAsync(subject, useSchemaId).ConfigureAwait(false);
                 return await schemaRegistryClient.LookupSchemaAsync(subject, schemaForId, false, false)
                     .ConfigureAwait(continueOnCapturedContext: false);
             }
diff --git a/src/Confluent.SchemaRegistry/CachedSchemaRegistryClient.cs b/src/Confluent.SchemaRegistry/CachedSchemaRegistryClient.cs
@@ -444,15 +444,15 @@ public Task<int> GetSchemaIdAsync(string subject, string avroSchema, bool normal
         /// <inheritdoc/>
         public async Task<int> GetSchemaIdAsync(string subject, Schema schema, bool normalize = false)
         {
-            var registeredSchema = await LookupSchemaAsync(subject, schema, true, normalize);
+            var registeredSchema = await LookupSchemaAsync(subject, schema, true, normalize).ConfigureAwait(false);
             return registeredSchema.Id;
         }
 
 
         /// <inheritdoc/>
         public async Task<int> RegisterSchemaAsync(string subject, Schema schema, bool normalize = false)
         {
-            var registeredSchema = await RegisterSchemaWithResponseAsync(subject, schema, normalize);
+            var registeredSchema = await RegisterSchemaWithResponseAsync(subject, schema, normalize).ConfigureAwait(false);
             return registeredSchema.Id;
         }
 
@@ -464,7 +464,7 @@ public async Task<RegisteredSchema> RegisterSchemaWithResponseAsync(string subje
             {
                 if (registeredSchemaBySchema.TryGetValue(schema, out var registeredSchema))
                 {
-                    return await registeredSchema;
+                    return await registeredSchema.ConfigureAwait(false);
                 }
             }
 
@@ -494,7 +494,7 @@ public async Task<RegisteredSchema> LookupSchemaAsync(string subject, Schema sch
             {
                 if (registeredSchemaBySchema.TryGetValue(schema, out var registeredSchema))
                 {
-                    var result = await registeredSchema;
+                    var result = await registeredSchema.ConfigureAwait(false);
                     if (result.Version > 0)
                     {
                         return result;
@@ -517,7 +517,7 @@ public async Task<Schema> GetSchemaAsync(int id, string format = null)
             var schemaId = new SchemaId(id, format);
             if (schemaById.TryGetValue(schemaId, out var schema))
             {
-                return await schema;
+                return await schema.ConfigureAwait(false);
             }
             
             CleanCacheIfFull();
@@ -531,7 +531,7 @@ public async Task<Schema> GetSchemaBySubjectAndIdAsync(string subject, int id, s
             var schemaId = new SchemaId(id, format);
             if (this.schemaById.TryGetValue(schemaId, out var schema))
             {
-                return await schema;
+                return await schema.ConfigureAwait(false);
             }
 
             return await schemaById.GetOrAddAsync(schemaId, _ => restService.GetSchemaBySubjectAndIdAsync(subject, id, format)).ConfigureAwait(continueOnCapturedContext: false);
@@ -544,7 +544,7 @@ public async Task<Schema> GetSchemaByGuidAsync(string guid, string format = null
             var schemaGuid = new SchemaGuid(guid, format);
             if (this.schemaByGuid.TryGetValue(schemaGuid, out var schema))
             {
-                return await schema;
+                return await schema.ConfigureAwait(false);
             }
             
             return await schemaByGuid.GetOrAddAsync(schemaGuid, _ => restService.GetSchemaByGuidAsync(guid, format)).ConfigureAwait(continueOnCapturedContext: false);
@@ -558,7 +558,7 @@ public async Task<RegisteredSchema> GetRegisteredSchemaAsync(string subject, int
             {
                 if (schemaByVersion.TryGetValue(version, out var schema))
                 {
-                    return await schema;
+                    return await schema.ConfigureAwait(false);
                 }
             }
             
@@ -582,7 +582,7 @@ public async Task<RegisteredSchema> GetRegisteredSchemaAsync(string subject, int
         [Obsolete(
             "Superseded by GetRegisteredSchemaAsync(string subject, int version). This method will be removed in a future release.")]
         public async Task<string> GetSchemaAsync(string subject, int version)
-            => (await GetRegisteredSchemaAsync(subject, version)).SchemaString;
+            => (await GetRegisteredSchemaAsync(subject, version).ConfigureAwait(false)).SchemaString;
 
 
         /// <inheritdoc/>
diff --git a/src/Confluent.SchemaRegistry/Rest/Authentication/BearerAuthenticationHeaderValueProvider.cs b/src/Confluent.SchemaRegistry/Rest/Authentication/BearerAuthenticationHeaderValueProvider.cs
diff --git a/src/Confluent.SchemaRegistry/Rest/RestService.cs b/src/Confluent.SchemaRegistry/Rest/RestService.cs
diff --git a/src/Shared/ConcurrentDictionaryExtensions.cs b/src/Shared/ConcurrentDictionaryExtensions.cs

Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,8 @@ public void Configure(IEnumerable<KeyValuePair<string, string>> config,`
`44`	`44`
`45`	`45`	`public async Task<object> Transform(RuleContext ctx, object message)`
`46`	`46`	`{`
`47`		`- return await Execute(ctx, message, new Dictionary<string, object>() { { "message", message } });`
	`47`	`+ return await Execute(ctx, message, new Dictionary<string, object>() { { "message", message } })`
	`48`	`+ .ConfigureAwait(false);`
`48`	`49`	`}`
`49`	`50`
`50`	`51`	`public async Task<object> Execute(RuleContext ctx, object obj, IDictionary<string, object> args)`
`@@ -59,7 +60,7 @@ public async Task<object> Execute(RuleContext ctx, object obj, IDictionary<strin`
`59`	`60`	`object guardResult = false;`
`60`	`61`	`try`
`61`	`62`	`{`
`62`		`- guardResult = await Execute(ctx, guard, obj, args);`
	`63`	`+ guardResult = await Execute(ctx, guard, obj, args).ConfigureAwait(false);`
`63`	`64`	`}`
`64`	`65`	`catch (RuleException e)`
`65`	`66`	`{`
`@@ -75,7 +76,7 @@ public async Task<object> Execute(RuleContext ctx, object obj, IDictionary<strin`
`75`	`76`	`expr = expr.Substring(index + 1);`
`76`	`77`	`}`
`77`	`78`
`78`		`- return await Execute(ctx, expr, obj, args);`
	`79`	`+ return await Execute(ctx, expr, obj, args).ConfigureAwait(false);`
`79`	`80`	`}`
`80`	`81`
`81`	`82`	`private async Task<object> Execute(RuleContext ctx, string rule, object obj, IDictionary<string, object> args)`
Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ public async Task<object> Transform(RuleContext ctx, RuleContext.FieldContext fi`
`69`	`69`	`{ "tags", fieldCtx.Tags.ToList() },`
`70`	`70`	`{ "message", message }`
`71`	`71`	`}`
`72`		`- );`
	`72`	`+ ).ConfigureAwait(false);`
`73`	`73`	`if (result is ByteString)`
`74`	`74`	`{`
`75`	`75`	`result = ((ByteString)result).ToByteArray();`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ public override async Task<GenericRecord> DeserializeAsync(ReadOnlyMemory<byte>`
`56`	`56`	`return isNull`
`57`	`57`	`? default`
`58`	`58`	`: await Deserialize(context.Topic, context.Headers, data.ToArray(),`
`59`		`- context.Component == MessageComponentType.Key);`
	`59`	`+ context.Component == MessageComponentType.Key).ConfigureAwait(false);`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`public async Task<GenericRecord> Deserialize(string topic, Headers headers, byte[] array, bool isKey)`
`@@ -85,7 +85,7 @@ public async Task<GenericRecord> Deserialize(string topic, Headers headers, byte`
`85`	`85`	`SchemaId writerId = new SchemaId(SchemaType.Avro);`
`86`	`86`	`using (var stream = schemaIdDeserializer.Deserialize(array, context, ref writerId))`
`87`	`87`	`{`
`88`		`- (writerSchemaJson, writerSchema) = await GetWriterSchema(subject, writerId);`
	`88`	`+ (writerSchemaJson, writerSchema) = await GetWriterSchema(subject, writerId).ConfigureAwait(false);`
`89`	`89`	`if (subject == null)`
`90`	`90`	`{`
`91`	`91`	`subject = GetSubjectName(topic, isKey, writerSchema.Fullname);`
`@@ -126,7 +126,7 @@ public async Task<GenericRecord> Deserialize(string topic, Headers headers, byte`
`126`	`126`	`.ContinueWith(t => (JToken)t.Result)`
`127`	`127`	`.ConfigureAwait(continueOnCapturedContext: false);`
`128`	`128`	`readerSchemaJson = latestSchema;`
`129`		`- readerSchema = await GetParsedSchema(readerSchemaJson);`
	`129`	`+ readerSchema = await GetParsedSchema(readerSchemaJson).ConfigureAwait(false);`
`130`	`130`	`Avro.IO.Decoder decoder = new JsonDecoder(readerSchema, json.ToString(Formatting.None));`
`131`	`131`
`132`	`132`	`datumReader = new GenericReader<GenericRecord>(readerSchema, readerSchema);`
`@@ -137,14 +137,14 @@ public async Task<GenericRecord> Deserialize(string topic, Headers headers, byte`
`137`	`137`	`if (latestSchema != null)`
`138`	`138`	`{`
`139`	`139`	`readerSchemaJson = latestSchema;`
`140`		`- readerSchema = await GetParsedSchema(readerSchemaJson);`
	`140`	`+ readerSchema = await GetParsedSchema(readerSchemaJson).ConfigureAwait(false);`
`141`	`141`	`}`
`142`	`142`	`else`
`143`	`143`	`{`
`144`	`144`	`readerSchemaJson = writerSchemaJson;`
`145`	`145`	`readerSchema = writerSchema;`
`146`	`146`	`}`
`147`		`- datumReader = await GetDatumReader(writerSchema, readerSchema);`
	`147`	`+ datumReader = await GetDatumReader(writerSchema, readerSchema).ConfigureAwait(false);`
`148`	`148`	`data = datumReader.Read(default(GenericRecord), new BinaryDecoder(stream));`
`149`	`149`	`}`
`150`	`150`	`}`
Original file line number	Diff line number	Diff line change
`@@ -162,7 +162,7 @@ public async Task<byte[]> Serialize(string topic, Headers headers, GenericRecord`
`162`	`162`
`163`	`163`	`if (latestSchema != null)`
`164`	`164`	`{`
`165`		`- writerSchema = await GetParsedSchema(latestSchema);`
	`165`	`+ writerSchema = await GetParsedSchema(latestSchema).ConfigureAwait(false);`
`166`	`166`	`FieldTransformer fieldTransformer = async (ctx, transform, message) =>`
`167`	`167`	`{`
`168`	`168`	`return await AvroUtils.Transform(ctx, writerSchema, message, transform).ConfigureAwait(false);`
Original file line number	Diff line number	Diff line change
`@@ -107,7 +107,7 @@ public override async Task<T> DeserializeAsync(ReadOnlyMemory<byte> data, bool i`
`107`	`107`	`return isNull`
`108`	`108`	`? default`
`109`	`109`	`: await Deserialize(context.Topic, context.Headers, data.ToArray(),`
`110`		`- context.Component == MessageComponentType.Key);`
	`110`	`+ context.Component == MessageComponentType.Key).ConfigureAwait(false);`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`public async Task<T> Deserialize(string topic, Headers headers, byte[] array, bool isKey)`
`@@ -134,7 +134,7 @@ public async Task<T> Deserialize(string topic, Headers headers, byte[] array, bo`
`134`	`134`	`SchemaId writerId = new SchemaId(SchemaType.Avro);`
`135`	`135`	`using (var stream = schemaIdDeserializer.Deserialize(array, context, ref writerId))`
`136`	`136`	`{`
`137`		`- (writerSchemaJson, writerSchema) = await GetWriterSchema(subject, writerId);`
	`137`	`+ (writerSchemaJson, writerSchema) = await GetWriterSchema(subject, writerId).ConfigureAwait(false);`
`138`	`138`	`if (subject == null)`
`139`	`139`	`{`
`140`	`140`	`subject = GetSubjectName(topic, isKey, writerSchema.Fullname);`
`@@ -181,13 +181,15 @@ public async Task<T> Deserialize(string topic, Headers headers, byte[] array, bo`
`181`	`181`	`}`
`182`	`182`	`else`
`183`	`183`	`{`
`184`		`- datumReader = await GetDatumReader(writerSchema, ReaderSchema);`
	`184`	`+ datumReader = await GetDatumReader(writerSchema, ReaderSchema).ConfigureAwait(false);`
`185`	`185`	`data = Read(datumReader, new BinaryDecoder(stream));`
`186`	`186`	`}`
`187`	`187`	`}`
`188`	`188`
`189`	`189`	`Schema readerSchemaJson = latestSchema ?? writerSchemaJson;`
`190`		`- Avro.Schema readerSchema = latestSchema != null ? await GetParsedSchema(latestSchema) : writerSchema;`
	`190`	`+ Avro.Schema readerSchema = latestSchema != null`
	`191`	`+ ? await GetParsedSchema(latestSchema).ConfigureAwait(false)`
	`192`	`+ : writerSchema;`
`191`	`193`	`FieldTransformer fieldTransformer = async (ctx, transform, message) =>`
`192`	`194`	`{`
`193`	`195`	`return await AvroUtils.Transform(ctx, readerSchema, message, transform).ConfigureAwait(false);`
Original file line number	Diff line number	Diff line change
`@@ -204,7 +204,7 @@ public async Task<byte[]> Serialize(string topic, Headers headers, T data, bool`
`204`	`204`
`205`	`205`	`if (latestSchema != null)`
`206`	`206`	`{`
`207`		`- var schema = await GetParsedSchema(latestSchema);`
	`207`	`+ var schema = await GetParsedSchema(latestSchema).ConfigureAwait(false);`
`208`	`208`	`FieldTransformer fieldTransformer = async (ctx, transform, message) =>`
`209`	`209`	`{`
`210`	`210`	`return await AvroUtils.Transform(ctx, schema, message, transform).ConfigureAwait(false);`
Original file line number	Diff line number	Diff line change
`@@ -193,7 +193,8 @@ public override async Task<T> DeserializeAsync(ReadOnlyMemory<byte> data, bool i`
`193`	`193`	`{`
`194`	`194`	`if (schemaRegistryClient != null)`
`195`	`195`	`{`
`196`		`- (writerSchemaJson, writerSchema) = await GetWriterSchema(subject, writerId);`
	`196`	`+ (writerSchemaJson, writerSchema) = await GetWriterSchema(subject, writerId)`
	`197`	`+ .ConfigureAwait(false);`
`197`	`198`	`if (subject == null)`
`198`	`199`	`{`
`199`	`200`	`subject = GetSubjectName(topic, isKey, writerSchema.Title);`
`@@ -210,7 +211,7 @@ public override async Task<T> DeserializeAsync(ReadOnlyMemory<byte> data, bool i`
`210`	`211`	`migrations = await GetMigrations(subject, writerSchemaJson, latestSchema)`
`211`	`212`	`.ConfigureAwait(continueOnCapturedContext: false);`
`212`	`213`	`readerSchemaJson = latestSchema;`
`213`		`- readerSchema = await GetParsedSchema(latestSchema);`
	`214`	`+ readerSchema = await GetParsedSchema(latestSchema).ConfigureAwait(false);`
`214`	`215`	`}`
`215`	`216`	`else if (schema != null)`
`216`	`217`	`{`
`@@ -296,7 +297,7 @@ protected override async Task<JsonSchema> ParseSchema(Schema schema)`
`296`	`297`	`JsonSchemaResolver utils = new JsonSchemaResolver(`
`297`	`298`	`schemaRegistryClient, schema, jsonSchemaGeneratorSettings);`
`298`	`299`
`299`		`- return await utils.GetResolvedSchema();`
	`300`	`+ return await utils.GetResolvedSchema().ConfigureAwait(false);`
`300`	`301`	`}`
`301`	`302`	`}`
`302`	`303`	`}`
Original file line number	Diff line number	Diff line change
`@@ -79,8 +79,8 @@ public JsonSchemaResolver(ISchemaRegistryClient schemaRegistryClient, Schema sch`
`79`	`79`	`public async Task<JsonSchema> GetResolvedSchema(){`
`80`	`80`	`if (resolvedJsonSchema == null)`
`81`	`81`	`{`
`82`		`- await CreateSchemaDictUtil(root);`
`83`		`- resolvedJsonSchema = await GetSchemaUtil(root);`
	`82`	`+ await CreateSchemaDictUtil(root).ConfigureAwait(false);`
	`83`	`+ resolvedJsonSchema = await GetSchemaUtil(root).ConfigureAwait(false);`
`84`	`84`	`}`
`85`	`85`	`return resolvedJsonSchema;`
`86`	`86`	`}`
`@@ -94,8 +94,9 @@ private async Task CreateSchemaDictUtil(Schema root, string referenceName = null`
`94`	`94`	`{`
`95`	`95`	`foreach (var reference in root.References)`
`96`	`96`	`{`
`97`		`- Schema refSchemaRes = await schemaRegistryClient.GetRegisteredSchemaAsync(reference.Subject, reference.Version, false);`
`98`		`- await CreateSchemaDictUtil(refSchemaRes, reference.Name);`
	`97`	`+ Schema refSchemaRes = await schemaRegistryClient.GetRegisteredSchemaAsync(reference.Subject, reference.Version, false)`
	`98`	`+ .ConfigureAwait(false);`
	`99`	`+ await CreateSchemaDictUtil(refSchemaRes, reference.Name).ConfigureAwait(false);`
`99`	`100`	`}`
`100`	`101`	`}`
`101`	`102`	`}`
`@@ -107,7 +108,7 @@ private async Task<JsonSchema> GetSchemaUtil(Schema root)`
`107`	`108`	`{`
`108`	`109`	`if (!dictSchemaNameToJsonSchema.ContainsKey(x.Name))`
`109`	`110`	`{`
`110`		`- var jsonSchema = await GetSchemaUtil(dictSchemaNameToSchema[x.Name]);`
	`111`	`+ var jsonSchema = await GetSchemaUtil(dictSchemaNameToSchema[x.Name]).ConfigureAwait(false);`
`111`	`112`	`dictSchemaNameToJsonSchema.Add(x.Name, jsonSchema);`
`112`	`113`	`}`
`113`	`114`	`}`
`@@ -125,7 +126,7 @@ private async Task<JsonSchema> GetSchemaUtil(Schema root)`
`125`	`126`	`string rootStr = root.SchemaString;`
`126`	`127`	`JObject schema = JObject.Parse(rootStr);`
`127`	`128`	`string schemaId = (string)schema["$id"] ?? "";`
`128`		`- return await JsonSchema.FromJsonAsync(rootStr, schemaId, factory);`
	`129`	`+ return await JsonSchema.FromJsonAsync(rootStr, schemaId, factory).ConfigureAwait(false);`
`129`	`130`	`}`
`130`	`131`
`131`	`132`	`private class CustomJsonReferenceResolver : JsonReferenceResolver`
`@@ -163,7 +164,7 @@ public override async Task<IJsonReference> ResolveFileReferenceAsync(string file`
`163`	`164`	`return schema;`
`164`	`165`	`}`
`165`	`166`
`166`		`- return await base.ResolveFileReferenceAsync(filePath, cancellationToken);`
	`167`	`+ return await base.ResolveFileReferenceAsync(filePath, cancellationToken).ConfigureAwait(false);`
`167`	`168`	`}`
`168`	`169`
`169`	`170`	`public override async Task<IJsonReference> ResolveUrlReferenceAsync(string url, CancellationToken cancellationToken = default)`
`@@ -189,7 +190,7 @@ public override async Task<IJsonReference> ResolveUrlReferenceAsync(string url,`
`189`	`190`	`}`
`190`	`191`	`}`
`191`	`192`
`192`		`- return await base.ResolveUrlReferenceAsync(url, cancellationToken);`
	`193`	`+ return await base.ResolveUrlReferenceAsync(url, cancellationToken).ConfigureAwait(false);`
`193`	`194`	`}`
`194`	`195`	`}`
`195`	`196`	`}`
Original file line number	Diff line number	Diff line change
`@@ -282,7 +282,7 @@ protected override async Task<JsonSchema> ParseSchema(Schema schema)`
`282`	`282`	`{`
`283`	`283`	`JsonSchemaResolver utils = new JsonSchemaResolver(`
`284`	`284`	`schemaRegistryClient, schema, jsonSchemaGeneratorSettings);`
`285`		`- return await utils.GetResolvedSchema();`
	`285`	`+ return await utils.GetResolvedSchema().ConfigureAwait(false);`
`286`	`286`	`}`
`287`	`287`	`}`
`288`	`288`	`}`
Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,7 @@ public override async Task<T> DeserializeAsync(ReadOnlyMemory<byte> data, bool i`
`136`	`136`	`{`
`137`	`137`	`if (schemaRegistryClient != null)`
`138`	`138`	`{`
`139`		`- (writerSchema, fdSet) = await GetWriterSchema(subject, writerId);`
	`139`	`+ (writerSchema, fdSet) = await GetWriterSchema(subject, writerId).ConfigureAwait(false);`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`message = parser.ParseFrom(stream);`