Apply ConfigureAwait(false) and Argument.ThrowIfNull

lilith · lilith · commit a21119892e63 · 2024-03-07T22:43:58.000-07:00
diff --git a/src/Imageflow/Bindings/JobContext.cs b/src/Imageflow/Bindings/JobContext.cs
@@ -451,10 +451,7 @@ public void AddInputBytes(int ioId, ArraySegment<byte> buffer)
     /// <exception cref="ArgumentOutOfRangeException"></exception>
     public void AddInputBytes(int ioId, byte[] buffer, long offset, long count)
     {
-        if (buffer == null)
-        {
-            throw new ArgumentNullException(nameof(buffer));
-        }
+        Argument.ThrowIfNull(buffer);
 
         if (offset > int.MaxValue)
         {
@@ -520,10 +517,7 @@ public void AddInputBytes(int ioId, ReadOnlySpan<byte> data)
     /// <exception cref="ArgumentNullException"></exception>
     public void AddInputBytesPinned(int ioId, byte[] buffer)
     {
-        if (buffer == null)
-        {
-            throw new ArgumentNullException(nameof(buffer));
-        }
+        Argument.ThrowIfNull(buffer);
 
         AddInputBytesPinned(ioId, new ReadOnlyMemory<byte>(buffer), MemoryLifetimePromise.MemoryIsOwnedByRuntime);
     }
@@ -553,10 +547,7 @@ public void AddInputBytesPinned(int ioId, ArraySegment<byte> buffer)
     /// <exception cref="ArgumentOutOfRangeException"></exception>
     public void AddInputBytesPinned(int ioId, byte[] buffer, long offset, long count)
     {
-        if (buffer == null)
-        {
-            throw new ArgumentNullException(nameof(buffer));
-        }
+        Argument.ThrowIfNull(buffer);
 
         if (offset > int.MaxValue)
         {
diff --git a/src/Imageflow/Fluent/BufferedStreamSource.cs b/src/Imageflow/Fluent/BufferedStreamSource.cs
@@ -83,7 +83,7 @@ public async ValueTask<ReadOnlyMemory<byte>> BorrowReadOnlyMemoryAsync(Cancellat
             _underlying.Seek(0, SeekOrigin.Begin);
         }
         _copy = new RecyclableMemoryStream(Mgr, "BufferedStreamSource: IMemorySource", _underlying.CanSeek ? _underlying.Length : 0);
-        await _underlying.CopyToAsync(_copy, 81920, cancellationToken);
+        await _underlying.CopyToAsync(_copy, 81920, cancellationToken).ConfigureAwait(false);
         _copy.Seek(0, SeekOrigin.Begin);
         if (!TryGetWrittenMemory(out segment))
         {
diff --git a/src/Imageflow/Fluent/FinishJobBuilder.cs b/src/Imageflow/Fluent/FinishJobBuilder.cs
@@ -89,7 +89,7 @@ public async Task<BuildJobResult> InProcessAndDisposeAsync()
         BuildJobResult r;
         try
         {
-            r = await InProcessAsync();
+            r = await InProcessAsync().ConfigureAwait(false);
         }
         finally
         {
diff --git a/src/Imageflow/Fluent/IOutputDestinationExtensions.cs b/src/Imageflow/Fluent/IOutputDestinationExtensions.cs
@@ -25,14 +25,14 @@ internal static async ValueTask AdaptiveWriteAllAsync(this IOutputDestination de
     {
         if (dest is IAsyncOutputSink sink)
         {
-            await sink.FastRequestCapacityAsync(data.Length);
-            await sink.FastWriteAsync(data, cancellationToken);
-            await sink.FastFlushAsync(cancellationToken);
+            await sink.FastRequestCapacityAsync(data.Length).ConfigureAwait(false);
+            await sink.FastWriteAsync(data, cancellationToken).ConfigureAwait(false);
+            await sink.FastFlushAsync(cancellationToken).ConfigureAwait(false);
             return;
         }
-        await dest.RequestCapacityAsync(data.Length);
-        await dest.AdaptedWriteAsync(data, cancellationToken);
-        await dest.FlushAsync(cancellationToken);
+        await dest.RequestCapacityAsync(data.Length).ConfigureAwait(false);
+        await dest.AdaptedWriteAsync(data, cancellationToken).ConfigureAwait(false);
+        await dest.FlushAsync(cancellationToken).ConfigureAwait(false);
     }
 
     internal static async ValueTask AdaptedWriteAsync(this IOutputDestination dest, ReadOnlyMemory<byte> data, CancellationToken cancellationToken)
@@ -86,14 +86,14 @@ internal static void AdaptedWrite(this IOutputDestination dest, ReadOnlySpan<byt
     [Obsolete("Users should not write to IOutputDestination directly; this is only for Imageflow internal use.")]
     public static async Task CopyFromStreamAsync(this IOutputDestination dest, Stream stream,
         CancellationToken cancellationToken)
-    => await dest.CopyFromStreamAsyncInternal(stream, cancellationToken);
+    => await dest.CopyFromStreamAsyncInternal(stream, cancellationToken).ConfigureAwait(false);
 
     internal static async Task CopyFromStreamAsyncInternal(this IOutputDestination dest, Stream stream,
         CancellationToken cancellationToken)
     {
         if (stream is { CanRead: true, CanSeek: true })
         {
-            await dest.RequestCapacityAsync((int)stream.Length);
+            await dest.RequestCapacityAsync((int)stream.Length).ConfigureAwait(false);
         }
 
         const int bufferSize = 81920;
@@ -107,6 +107,6 @@ await dest.WriteAsync(new ArraySegment<byte>(buffer, 0, bytesRead), cancellation
                 .ConfigureAwait(false);
         }
 
-        await dest.FlushAsync(cancellationToken);
+        await dest.FlushAsync(cancellationToken).ConfigureAwait(false);
     }
 }
diff --git a/src/Imageflow/Fluent/IOutputSink.cs b/src/Imageflow/Fluent/IOutputSink.cs
@@ -18,8 +18,8 @@ internal static class OutputSinkExtensions
 {
     public static async ValueTask WriteAllAsync(this IAsyncOutputSink sink, ReadOnlyMemory<byte> data, CancellationToken cancellationToken)
     {
-        await sink.FastRequestCapacityAsync(data.Length);
-        await sink.FastWriteAsync(data, cancellationToken);
-        await sink.FastFlushAsync(cancellationToken);
+        await sink.FastRequestCapacityAsync(data.Length).ConfigureAwait(false);
+        await sink.FastWriteAsync(data, cancellationToken).ConfigureAwait(false);
+        await sink.FastFlushAsync(cancellationToken).ConfigureAwait(false);
     }
 }
diff --git a/src/Imageflow/Fluent/ImageJob.cs b/src/Imageflow/Fluent/ImageJob.cs
@@ -23,7 +23,7 @@ internal void AddInput(int ioId, IAsyncMemorySource source)
     {
         if (_inputs.ContainsKey(ioId) || _outputs.ContainsKey(ioId))
         {
-            throw new ArgumentException("ioId", $"ioId {ioId} has already been assigned");
+            throw new ArgumentException($"ioId {ioId} has already been assigned", nameof(ioId));
         }
 
         _inputs.Add(ioId, source);
@@ -32,7 +32,7 @@ internal void AddOutput(int ioId, IOutputDestination destination)
     {
         if (_inputs.ContainsKey(ioId) || _outputs.ContainsKey(ioId))
         {
-            throw new ArgumentException("ioId", $"ioId {ioId} has already been assigned");
+            throw new ArgumentException($"ioId {ioId} has already been assigned", nameof(ioId));
         }
 
         _outputs.Add(ioId, destination);
@@ -148,7 +148,7 @@ public BuildEndpoint BuildCommandString(IBytesSource source, int? sourceIoId, IO
     public BuildEndpoint BuildCommandString(byte[] source, IOutputDestination dest, string commandString) => BuildCommandString(new MemorySource(source), dest, commandString);
 
     /// <summary>
-    /// Modify the input image (source) with the given command string and watermarks and encode to the (dest) 
+    /// Modify the input image (source) with the given command string and watermarks and encode to the (dest)
     /// </summary>
     /// <param name="source"></param>
     /// <param name="dest"></param>
@@ -265,7 +265,7 @@ internal string ToJsonDebug(SecurityOptions? securityOptions = default)
     internal async Task<BuildJobResult> FinishAsync(JobExecutionOptions executionOptions, SecurityOptions? securityOptions, CancellationToken cancellationToken)
     {
         var inputByteArrays = await Task.WhenAll(
-            _inputs.Select(async pair => new KeyValuePair<int, ReadOnlyMemory<byte>>(pair.Key, await pair.Value.BorrowReadOnlyMemoryAsync(cancellationToken))));
+            _inputs.Select(async pair => new KeyValuePair<int, ReadOnlyMemory<byte>>(pair.Key, await pair.Value.BorrowReadOnlyMemoryAsync(cancellationToken).ConfigureAwait(false)))).ConfigureAwait(false);
         using (var ctx = new JobContext())
         {
             foreach (var pair in inputByteArrays)
@@ -282,7 +282,7 @@ internal async Task<BuildJobResult> FinishAsync(JobExecutionOptions executionOpt
             var message = CreateJsonNodeForFramewiseWithSecurityOptions(securityOptions);
 
             var response = executionOptions.OffloadCpuToThreadPool
-                ? await Task.Run(() => ctx.InvokeExecute(message), cancellationToken)
+                ? await Task.Run(() => ctx.InvokeExecute(message), cancellationToken).ConfigureAwait(false)
                 : ctx.InvokeExecute(message);
 
             // TODO: Should we handle failure before copying out the buffers??
@@ -292,7 +292,7 @@ internal async Task<BuildJobResult> FinishAsync(JobExecutionOptions executionOpt
                 foreach (var pair in _outputs)
                 {
                     using var memOwner = ctx.BorrowOutputBufferMemoryAndAddReference(pair.Key);
-                    await pair.Value.AdaptiveWriteAllAsync(memOwner.Memory, cancellationToken);
+                    await pair.Value.AdaptiveWriteAllAsync(memOwner.Memory, cancellationToken).ConfigureAwait(false);
                 }
                 return BuildJobResult.From(response, _outputs);
             }
@@ -377,7 +377,7 @@ internal async Task CopyOutputsToDestinations(CancellationToken token)
             {
                 using (var stream = pair.Key.ReadFromBeginning())
                 {
-                    await pair.Value.CopyFromStreamAsyncInternal(stream, token);
+                    await pair.Value.CopyFromStreamAsyncInternal(stream, token).ConfigureAwait(false);
                 }
             }
         }
@@ -404,15 +404,15 @@ private async Task<SubprocessFilesystemJob> PrepareForSubprocessAsync(Cancellati
 
             var inputFiles = (await Task.WhenAll(_inputs.Select(async pair =>
             {
-                var bytes = await pair.Value.BorrowReadOnlyMemoryAsync(cancellationToken);
+                var bytes = await pair.Value.BorrowReadOnlyMemoryAsync(cancellationToken).ConfigureAwait(false);
 
                 var file = job.Provider.Create(cleanupFiles, bytes.Length);
                 job.Cleanup.Add(file);
                 return (io_id: pair.Key, direction: "in",
                     io: new JsonObject { { "file", file.Path } },
                     bytes, bytes.Length, File: file);
 
-            }))).ToArray();
+            })).ConfigureAwait(false)).ToArray();
 
             var outputCapacity = outputBufferCapacity ?? inputFiles.Max(v => v.Length) * 2;
             var outputFiles = _outputs.Select(pair =>
@@ -427,7 +427,7 @@ private async Task<SubprocessFilesystemJob> PrepareForSubprocessAsync(Cancellati
             foreach (var f in inputFiles)
             {
                 using var accessor = f.File.WriteFromBeginning();
-                await accessor.WriteMemoryAsync(f.bytes, cancellationToken);
+                await accessor.WriteMemoryAsync(f.bytes, cancellationToken).ConfigureAwait(false);
             }
 
             // job.JobMessage = new
@@ -505,7 +505,7 @@ internal async Task<BuildJobResult> FinishInSubprocessAsync(SecurityOptions? sec
             throw new FileNotFoundException("Cannot find imageflow_tool using path \"" + imageflowToolPath + "\" and currect folder \"" + Directory.GetCurrentDirectory() + "\"");
         }
 
-        using (var job = await PrepareForSubprocessAsync(cancellationToken, securityOptions, true, outputBufferCapacity))
+        using (var job = await PrepareForSubprocessAsync(cancellationToken, securityOptions, true, outputBufferCapacity).ConfigureAwait(false))
         {
 
             var startInfo = new ProcessStartInfo
@@ -517,7 +517,7 @@ internal async Task<BuildJobResult> FinishInSubprocessAsync(SecurityOptions? sec
                 FileName = imageflowToolPath
             };
 
-            var results = await ProcessEx.RunAsync(startInfo, cancellationToken);
+            var results = await ProcessEx.RunAsync(startInfo, cancellationToken).ConfigureAwait(false);
 
             var output = results.GetBufferedOutputStream();
             var errors = results.GetStandardErrorString();
@@ -535,7 +535,7 @@ internal async Task<BuildJobResult> FinishInSubprocessAsync(SecurityOptions? sec
                 }
             }
 
-            await job.CopyOutputsToDestinations(cancellationToken);
+            await job.CopyOutputsToDestinations(cancellationToken).ConfigureAwait(false);
 
             var outputMemory = output.GetWrittenMemory();
             return BuildJobResult.From(new MemoryJsonResponse(results.ExitCode, outputMemory), _outputs);
@@ -544,7 +544,7 @@ internal async Task<BuildJobResult> FinishInSubprocessAsync(SecurityOptions? sec
 
     internal async Task<IPreparedFilesystemJob> WriteJsonJobAndInputs(CancellationToken cancellationToken, SecurityOptions? securityOptions, bool deleteFilesOnDispose)
     {
-        return await PrepareForSubprocessAsync(cancellationToken, securityOptions, deleteFilesOnDispose);
+        return await PrepareForSubprocessAsync(cancellationToken, securityOptions, deleteFilesOnDispose).ConfigureAwait(false);
     }
 
     private readonly List<BuildItemBase> _nodesCreated = new List<BuildItemBase>(10);
@@ -598,10 +598,10 @@ private static IEnumerable<Tuple<long, long, EdgeKind>> CollectEdges(ICollection
     internal JsonNode ToFramewise()
     {
         var nodes = CollectUnique();
-        return ToFramewiseGraph(nodes);
+        return ImageJob.ToFramewiseGraph(nodes);
     }
 
-    private JsonNode ToFramewiseGraph(ICollection<BuildItemBase> uniqueNodes)
+    private static JsonNode ToFramewiseGraph(ICollection<BuildItemBase> uniqueNodes)
     {
         var lowestUid = LowestUid(uniqueNodes) ?? 0;
         var edges = CollectEdges(uniqueNodes)
@@ -707,7 +707,7 @@ public static async Task<ImageInfo> GetImageInfo(IBytesSource image, Cancellatio
     {
         try
         {
-            var inputByteArray = await image.GetBytesAsync(cancellationToken);
+            var inputByteArray = await image.GetBytesAsync(cancellationToken).ConfigureAwait(false);
             using (var ctx = new JobContext())
             {
                 ctx.AddInputBytesPinned(0, inputByteArray);
@@ -758,7 +758,7 @@ public static async ValueTask<ImageInfo> GetImageInfoAsync(IAsyncMemorySource im
     {
         try
         {
-            var inputMemory = await image.BorrowReadOnlyMemoryAsync(cancellationToken);
+            var inputMemory = await image.BorrowReadOnlyMemoryAsync(cancellationToken).ConfigureAwait(false);
             if (inputMemory.Length == 0)
             {
                 throw new ArgumentException("Input image is empty");
@@ -782,7 +782,7 @@ public static async ValueTask<ImageInfo> GetImageInfoAsync(IAsyncMemorySource im
         }
     }
     /// <summary>
-    /// Returns true if it is likely that Imageflow can decode the given image based on the first 12 bytes of the file. 
+    /// Returns true if it is likely that Imageflow can decode the given image based on the first 12 bytes of the file.
     /// </summary>
     /// <param name="first12Bytes">The first 12 or more bytes of the file</param>
     /// <returns></returns>
@@ -795,7 +795,7 @@ public static bool CanDecodeBytes(byte[] first12Bytes)
     /// <summary>
     /// Returns a MIME type string such as "image/jpeg" based on the provided first 12 bytes of the file.
     /// Only guaranteed to work for image types Imageflow supports, but support for more file types may be added
-    /// later. 
+    /// later.
     /// </summary>
     /// <param name="first12Bytes">The first 12 or more bytes of the file</param>
     /// <returns></returns>
diff --git a/src/Imageflow/Fluent/JobExecutionOptions.cs b/src/Imageflow/Fluent/JobExecutionOptions.cs
@@ -2,5 +2,5 @@ namespace Imageflow.Fluent;
 
 internal class JobExecutionOptions
 {
-    internal bool OffloadCpuToThreadPool { get; set; } = false;
+    internal bool OffloadCpuToThreadPool { get; set; }
 }
diff --git a/src/Imageflow/Fluent/MemorySource.cs b/src/Imageflow/Fluent/MemorySource.cs
@@ -11,7 +11,7 @@ public sealed class MemorySource : IAsyncMemorySource, IMemorySource
 
     public static IAsyncMemorySource TakeOwnership(IMemoryOwner<byte> ownedMemory, MemoryLifetimePromise promise)
     {
-        ArgumentNullThrowHelper.ThrowIfNull(ownedMemory);
+        Argument.ThrowIfNull(ownedMemory);
         if (promise != MemoryLifetimePromise.MemoryOwnerDisposedByMemorySource)
         {
             throw new ArgumentException(
@@ -26,7 +26,7 @@ private MemorySource(ReadOnlyMemory<byte>? borrowedMemory, IMemoryOwner<byte>? o
     {
         if (promise == MemoryLifetimePromise.MemoryOwnerDisposedByMemorySource)
         {
-            ArgumentNullThrowHelper.ThrowIfNull(ownedMemory);
+            Argument.ThrowIfNull(ownedMemory);
             if (borrowedMemory.HasValue)
             {
                 throw new ArgumentException(
@@ -39,7 +39,7 @@ private MemorySource(ReadOnlyMemory<byte>? borrowedMemory, IMemoryOwner<byte>? o
             throw new ArgumentNullException(nameof(borrowedMemory));
         }
 
-        ArgumentNullThrowHelper.ThrowIfNull(borrowedMemory);
+        Argument.ThrowIfNull(borrowedMemory);
         _borrowedMemory = borrowedMemory;
         _ownedMemory = ownedMemory;
     }
diff --git a/src/Imageflow/Fluent/PerformanceDetails.cs b/src/Imageflow/Fluent/PerformanceDetails.cs
@@ -43,7 +43,7 @@ public string GetFirstFrameSummary()
         foreach (var n in Frames.First().Nodes)
         {
             sb.Append(n.Name);
-            sb.Append("(");
+            sb.Append('(');
             sb.Append((n.WallMicroseconds / 1000.0).ToString("0.####"));
             sb.Append("ms) ");
         }
diff --git a/src/Imageflow/Fluent/StreamSource.cs b/src/Imageflow/Fluent/StreamSource.cs
@@ -51,7 +51,7 @@ public async Task<ArraySegment<byte>> GetBytesAsync(CancellationToken cancellati
         if (_copy == null)
         {
             _copy = new RecyclableMemoryStream(Mgr, "StreamSource: IBytesSource", length);
-            await underlying.CopyToAsync(_copy, 81920, cancellationToken);
+            await underlying.CopyToAsync(_copy, 81920, cancellationToken).ConfigureAwait(false);
         }
 
         return new ArraySegment<byte>(_copy.GetBuffer(), 0,
diff --git a/src/Imageflow/IO/ProcessEx.cs b/src/Imageflow/IO/ProcessEx.cs
@@ -131,7 +131,7 @@ public static async Task<ProcessResults> RunAsync(ProcessStartInfo processStartI
             process.BeginOutputReadLine();
             process.BeginErrorReadLine();
 
-            return await tcs.Task;
+            return await tcs.Task.ConfigureAwait(false);
         }
     }
 }
diff --git a/src/Imageflow/Internal.Helpers/ArgumentNullThrowHelperPolyfill.cs b/src/Imageflow/Internal.Helpers/ArgumentNullThrowHelperPolyfill.cs
@@ -7,7 +7,7 @@ namespace Imageflow.Internal.Helpers;
 // The .NET Foundation licenses this file to you under the MIT license.
 // Imazen licenses any changes to th
 
-internal static partial class ArgumentNullThrowHelper
+internal static class Argument
 {
     /// <summary>Throws an <see cref="ArgumentNullException"/> if <paramref name="argument"/> is null.</summary>
     /// <param name="argument">The reference type argument to validate as non-null.</param>
@@ -24,7 +24,7 @@ public static void ThrowIfNull(
             Throw(paramName);
         }
 #else
-        ArgumentNullException.ThrowIfNull(argument, paramName);
+        Argument.ThrowIfNull(argument, paramName);
 #endif
     }
 
@@ -44,7 +44,7 @@ public static void ThrowIf([DoesNotReturnIf(true)] bool condition, object instan
 #if NET8_0_OR_GREATER
 
         ObjectDisposedException.ThrowIf(condition, instance);
-#else 
+#else
         if (condition)
         {
             throw new ObjectDisposedException(instance?.GetType().Name);

Original file line number	Diff line number	Diff line change
`@@ -451,10 +451,7 @@ public void AddInputBytes(int ioId, ArraySegment<byte> buffer)`
`451`	`451`	`/// <exception cref="ArgumentOutOfRangeException"></exception>`
`452`	`452`	`public void AddInputBytes(int ioId, byte[] buffer, long offset, long count)`
`453`	`453`	`{`
`454`		`- if (buffer == null)`
`455`		`- {`
`456`		`- throw new ArgumentNullException(nameof(buffer));`
`457`		`- }`
	`454`	`+ Argument.ThrowIfNull(buffer);`
`458`	`455`
`459`	`456`	`if (offset > int.MaxValue)`
`460`	`457`	`{`
`@@ -520,10 +517,7 @@ public void AddInputBytes(int ioId, ReadOnlySpan<byte> data)`
`520`	`517`	`/// <exception cref="ArgumentNullException"></exception>`
`521`	`518`	`public void AddInputBytesPinned(int ioId, byte[] buffer)`
`522`	`519`	`{`
`523`		`- if (buffer == null)`
`524`		`- {`
`525`		`- throw new ArgumentNullException(nameof(buffer));`
`526`		`- }`
	`520`	`+ Argument.ThrowIfNull(buffer);`
`527`	`521`
`528`	`522`	`AddInputBytesPinned(ioId, new ReadOnlyMemory<byte>(buffer), MemoryLifetimePromise.MemoryIsOwnedByRuntime);`
`529`	`523`	`}`
`@@ -553,10 +547,7 @@ public void AddInputBytesPinned(int ioId, ArraySegment<byte> buffer)`
`553`	`547`	`/// <exception cref="ArgumentOutOfRangeException"></exception>`
`554`	`548`	`public void AddInputBytesPinned(int ioId, byte[] buffer, long offset, long count)`
`555`	`549`	`{`
`556`		`- if (buffer == null)`
`557`		`- {`
`558`		`- throw new ArgumentNullException(nameof(buffer));`
`559`		`- }`
	`550`	`+ Argument.ThrowIfNull(buffer);`
`560`	`551`
`561`	`552`	`if (offset > int.MaxValue)`
`562`	`553`	`{`
Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,7 @@ public async ValueTask<ReadOnlyMemory<byte>> BorrowReadOnlyMemoryAsync(Cancellat`
`83`	`83`	`_underlying.Seek(0, SeekOrigin.Begin);`
`84`	`84`	`}`
`85`	`85`	`_copy = new RecyclableMemoryStream(Mgr, "BufferedStreamSource: IMemorySource", _underlying.CanSeek ? _underlying.Length : 0);`
`86`		`- await _underlying.CopyToAsync(_copy, 81920, cancellationToken);`
	`86`	`+ await _underlying.CopyToAsync(_copy, 81920, cancellationToken).ConfigureAwait(false);`
`87`	`87`	`_copy.Seek(0, SeekOrigin.Begin);`
`88`	`88`	`if (!TryGetWrittenMemory(out segment))`
`89`	`89`	`{`
Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ public async Task<BuildJobResult> InProcessAndDisposeAsync()`
`89`	`89`	`BuildJobResult r;`
`90`	`90`	`try`
`91`	`91`	`{`
`92`		`- r = await InProcessAsync();`
	`92`	`+ r = await InProcessAsync().ConfigureAwait(false);`
`93`	`93`	`}`
`94`	`94`	`finally`
`95`	`95`	`{`
Original file line number	Diff line number	Diff line change
`@@ -25,14 +25,14 @@ internal static async ValueTask AdaptiveWriteAllAsync(this IOutputDestination de`
`25`	`25`	`{`
`26`	`26`	`if (dest is IAsyncOutputSink sink)`
`27`	`27`	`{`
`28`		`- await sink.FastRequestCapacityAsync(data.Length);`
`29`		`- await sink.FastWriteAsync(data, cancellationToken);`
`30`		`- await sink.FastFlushAsync(cancellationToken);`
	`28`	`+ await sink.FastRequestCapacityAsync(data.Length).ConfigureAwait(false);`
	`29`	`+ await sink.FastWriteAsync(data, cancellationToken).ConfigureAwait(false);`
	`30`	`+ await sink.FastFlushAsync(cancellationToken).ConfigureAwait(false);`
`31`	`31`	`return;`
`32`	`32`	`}`
`33`		`- await dest.RequestCapacityAsync(data.Length);`
`34`		`- await dest.AdaptedWriteAsync(data, cancellationToken);`
`35`		`- await dest.FlushAsync(cancellationToken);`
	`33`	`+ await dest.RequestCapacityAsync(data.Length).ConfigureAwait(false);`
	`34`	`+ await dest.AdaptedWriteAsync(data, cancellationToken).ConfigureAwait(false);`
	`35`	`+ await dest.FlushAsync(cancellationToken).ConfigureAwait(false);`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`internal static async ValueTask AdaptedWriteAsync(this IOutputDestination dest, ReadOnlyMemory<byte> data, CancellationToken cancellationToken)`
`@@ -86,14 +86,14 @@ internal static void AdaptedWrite(this IOutputDestination dest, ReadOnlySpan<byt`
`86`	`86`	`[Obsolete("Users should not write to IOutputDestination directly; this is only for Imageflow internal use.")]`
`87`	`87`	`public static async Task CopyFromStreamAsync(this IOutputDestination dest, Stream stream,`
`88`	`88`	`CancellationToken cancellationToken)`
`89`		`- => await dest.CopyFromStreamAsyncInternal(stream, cancellationToken);`
	`89`	`+ => await dest.CopyFromStreamAsyncInternal(stream, cancellationToken).ConfigureAwait(false);`
`90`	`90`
`91`	`91`	`internal static async Task CopyFromStreamAsyncInternal(this IOutputDestination dest, Stream stream,`
`92`	`92`	`CancellationToken cancellationToken)`
`93`	`93`	`{`
`94`	`94`	`if (stream is { CanRead: true, CanSeek: true })`
`95`	`95`	`{`
`96`		`- await dest.RequestCapacityAsync((int)stream.Length);`
	`96`	`+ await dest.RequestCapacityAsync((int)stream.Length).ConfigureAwait(false);`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`const int bufferSize = 81920;`
`@@ -107,6 +107,6 @@ await dest.WriteAsync(new ArraySegment<byte>(buffer, 0, bytesRead), cancellation`
`107`	`107`	`.ConfigureAwait(false);`
`108`	`108`	`}`
`109`	`109`
`110`		`- await dest.FlushAsync(cancellationToken);`
	`110`	`+ await dest.FlushAsync(cancellationToken).ConfigureAwait(false);`
`111`	`111`	`}`
`112`	`112`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,8 +18,8 @@ internal static class OutputSinkExtensions`
`18`	`18`	`{`
`19`	`19`	`public static async ValueTask WriteAllAsync(this IAsyncOutputSink sink, ReadOnlyMemory<byte> data, CancellationToken cancellationToken)`
`20`	`20`	`{`
`21`		`- await sink.FastRequestCapacityAsync(data.Length);`
`22`		`- await sink.FastWriteAsync(data, cancellationToken);`
`23`		`- await sink.FastFlushAsync(cancellationToken);`
	`21`	`+ await sink.FastRequestCapacityAsync(data.Length).ConfigureAwait(false);`
	`22`	`+ await sink.FastWriteAsync(data, cancellationToken).ConfigureAwait(false);`
	`23`	`+ await sink.FastFlushAsync(cancellationToken).ConfigureAwait(false);`
`24`	`24`	`}`
`25`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ internal void AddInput(int ioId, IAsyncMemorySource source)`
`23`	`23`	`{`
`24`	`24`	`if (_inputs.ContainsKey(ioId) \|\| _outputs.ContainsKey(ioId))`
`25`	`25`	`{`
`26`		`- throw new ArgumentException("ioId", $"ioId {ioId} has already been assigned");`
	`26`	`+ throw new ArgumentException($"ioId {ioId} has already been assigned", nameof(ioId));`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`_inputs.Add(ioId, source);`
`@@ -32,7 +32,7 @@ internal void AddOutput(int ioId, IOutputDestination destination)`
`32`	`32`	`{`
`33`	`33`	`if (_inputs.ContainsKey(ioId) \|\| _outputs.ContainsKey(ioId))`
`34`	`34`	`{`
`35`		`- throw new ArgumentException("ioId", $"ioId {ioId} has already been assigned");`
	`35`	`+ throw new ArgumentException($"ioId {ioId} has already been assigned", nameof(ioId));`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`_outputs.Add(ioId, destination);`
`@@ -148,7 +148,7 @@ public BuildEndpoint BuildCommandString(IBytesSource source, int? sourceIoId, IO`
`148`	`148`	`public BuildEndpoint BuildCommandString(byte[] source, IOutputDestination dest, string commandString) => BuildCommandString(new MemorySource(source), dest, commandString);`
`149`	`149`
`150`	`150`	`/// <summary>`
`151`		`- /// Modify the input image (source) with the given command string and watermarks and encode to the (dest)`
	`151`	`+ /// Modify the input image (source) with the given command string and watermarks and encode to the (dest)`
`152`	`152`	`/// </summary>`
`153`	`153`	`/// <param name="source"></param>`
`154`	`154`	`/// <param name="dest"></param>`
`@@ -265,7 +265,7 @@ internal string ToJsonDebug(SecurityOptions? securityOptions = default)`
`265`	`265`	`internal async Task<BuildJobResult> FinishAsync(JobExecutionOptions executionOptions, SecurityOptions? securityOptions, CancellationToken cancellationToken)`
`266`	`266`	`{`
`267`	`267`	`var inputByteArrays = await Task.WhenAll(`
`268`		`- _inputs.Select(async pair => new KeyValuePair<int, ReadOnlyMemory<byte>>(pair.Key, await pair.Value.BorrowReadOnlyMemoryAsync(cancellationToken))));`
	`268`	`+ _inputs.Select(async pair => new KeyValuePair<int, ReadOnlyMemory<byte>>(pair.Key, await pair.Value.BorrowReadOnlyMemoryAsync(cancellationToken).ConfigureAwait(false)))).ConfigureAwait(false);`
`269`	`269`	`using (var ctx = new JobContext())`
`270`	`270`	`{`
`271`	`271`	`foreach (var pair in inputByteArrays)`
`@@ -282,7 +282,7 @@ internal async Task<BuildJobResult> FinishAsync(JobExecutionOptions executionOpt`
`282`	`282`	`var message = CreateJsonNodeForFramewiseWithSecurityOptions(securityOptions);`
`283`	`283`
`284`	`284`	`var response = executionOptions.OffloadCpuToThreadPool`
`285`		`- ? await Task.Run(() => ctx.InvokeExecute(message), cancellationToken)`
	`285`	`+ ? await Task.Run(() => ctx.InvokeExecute(message), cancellationToken).ConfigureAwait(false)`
`286`	`286`	`: ctx.InvokeExecute(message);`
`287`	`287`
`288`	`288`	`// TODO: Should we handle failure before copying out the buffers??`
`@@ -292,7 +292,7 @@ internal async Task<BuildJobResult> FinishAsync(JobExecutionOptions executionOpt`
`292`	`292`	`foreach (var pair in _outputs)`
`293`	`293`	`{`
`294`	`294`	`using var memOwner = ctx.BorrowOutputBufferMemoryAndAddReference(pair.Key);`
`295`		`- await pair.Value.AdaptiveWriteAllAsync(memOwner.Memory, cancellationToken);`
	`295`	`+ await pair.Value.AdaptiveWriteAllAsync(memOwner.Memory, cancellationToken).ConfigureAwait(false);`
`296`	`296`	`}`
`297`	`297`	`return BuildJobResult.From(response, _outputs);`
`298`	`298`	`}`
`@@ -377,7 +377,7 @@ internal async Task CopyOutputsToDestinations(CancellationToken token)`
`377`	`377`	`{`
`378`	`378`	`using (var stream = pair.Key.ReadFromBeginning())`
`379`	`379`	`{`
`380`		`- await pair.Value.CopyFromStreamAsyncInternal(stream, token);`
	`380`	`+ await pair.Value.CopyFromStreamAsyncInternal(stream, token).ConfigureAwait(false);`
`381`	`381`	`}`
`382`	`382`	`}`
`383`	`383`	`}`
`@@ -404,15 +404,15 @@ private async Task<SubprocessFilesystemJob> PrepareForSubprocessAsync(Cancellati`
`404`	`404`
`405`	`405`	`var inputFiles = (await Task.WhenAll(_inputs.Select(async pair =>`
`406`	`406`	`{`
`407`		`- var bytes = await pair.Value.BorrowReadOnlyMemoryAsync(cancellationToken);`
	`407`	`+ var bytes = await pair.Value.BorrowReadOnlyMemoryAsync(cancellationToken).ConfigureAwait(false);`
`408`	`408`
`409`	`409`	`var file = job.Provider.Create(cleanupFiles, bytes.Length);`
`410`	`410`	`job.Cleanup.Add(file);`
`411`	`411`	`return (io_id: pair.Key, direction: "in",`
`412`	`412`	`io: new JsonObject { { "file", file.Path } },`
`413`	`413`	`bytes, bytes.Length, File: file);`
`414`	`414`
`415`		`- }))).ToArray();`
	`415`	`+ })).ConfigureAwait(false)).ToArray();`
`416`	`416`
`417`	`417`	`var outputCapacity = outputBufferCapacity ?? inputFiles.Max(v => v.Length) * 2;`
`418`	`418`	`var outputFiles = _outputs.Select(pair =>`
`@@ -427,7 +427,7 @@ private async Task<SubprocessFilesystemJob> PrepareForSubprocessAsync(Cancellati`
`427`	`427`	`foreach (var f in inputFiles)`
`428`	`428`	`{`
`429`	`429`	`using var accessor = f.File.WriteFromBeginning();`
`430`		`- await accessor.WriteMemoryAsync(f.bytes, cancellationToken);`
	`430`	`+ await accessor.WriteMemoryAsync(f.bytes, cancellationToken).ConfigureAwait(false);`
`431`	`431`	`}`
`432`	`432`
`433`	`433`	`// job.JobMessage = new`
`@@ -505,7 +505,7 @@ internal async Task<BuildJobResult> FinishInSubprocessAsync(SecurityOptions? sec`
`505`	`505`	`throw new FileNotFoundException("Cannot find imageflow_tool using path \"" + imageflowToolPath + "\" and currect folder \"" + Directory.GetCurrentDirectory() + "\"");`
`506`	`506`	`}`
`507`	`507`
`508`		`- using (var job = await PrepareForSubprocessAsync(cancellationToken, securityOptions, true, outputBufferCapacity))`
	`508`	`+ using (var job = await PrepareForSubprocessAsync(cancellationToken, securityOptions, true, outputBufferCapacity).ConfigureAwait(false))`
`509`	`509`	`{`
`510`	`510`
`511`	`511`	`var startInfo = new ProcessStartInfo`
`@@ -517,7 +517,7 @@ internal async Task<BuildJobResult> FinishInSubprocessAsync(SecurityOptions? sec`
`517`	`517`	`FileName = imageflowToolPath`
`518`	`518`	`};`
`519`	`519`
`520`		`- var results = await ProcessEx.RunAsync(startInfo, cancellationToken);`
	`520`	`+ var results = await ProcessEx.RunAsync(startInfo, cancellationToken).ConfigureAwait(false);`
`521`	`521`
`522`	`522`	`var output = results.GetBufferedOutputStream();`
`523`	`523`	`var errors = results.GetStandardErrorString();`
`@@ -535,7 +535,7 @@ internal async Task<BuildJobResult> FinishInSubprocessAsync(SecurityOptions? sec`
`535`	`535`	`}`
`536`	`536`	`}`
`537`	`537`
`538`		`- await job.CopyOutputsToDestinations(cancellationToken);`
	`538`	`+ await job.CopyOutputsToDestinations(cancellationToken).ConfigureAwait(false);`
`539`	`539`
`540`	`540`	`var outputMemory = output.GetWrittenMemory();`
`541`	`541`	`return BuildJobResult.From(new MemoryJsonResponse(results.ExitCode, outputMemory), _outputs);`
`@@ -544,7 +544,7 @@ internal async Task<BuildJobResult> FinishInSubprocessAsync(SecurityOptions? sec`
`544`	`544`
`545`	`545`	`internal async Task<IPreparedFilesystemJob> WriteJsonJobAndInputs(CancellationToken cancellationToken, SecurityOptions? securityOptions, bool deleteFilesOnDispose)`
`546`	`546`	`{`
`547`		`- return await PrepareForSubprocessAsync(cancellationToken, securityOptions, deleteFilesOnDispose);`
	`547`	`+ return await PrepareForSubprocessAsync(cancellationToken, securityOptions, deleteFilesOnDispose).ConfigureAwait(false);`
`548`	`548`	`}`
`549`	`549`
`550`	`550`	`private readonly List<BuildItemBase> _nodesCreated = new List<BuildItemBase>(10);`
`@@ -598,10 +598,10 @@ private static IEnumerable<Tuple<long, long, EdgeKind>> CollectEdges(ICollection`
`598`	`598`	`internal JsonNode ToFramewise()`
`599`	`599`	`{`
`600`	`600`	`var nodes = CollectUnique();`
`601`		`- return ToFramewiseGraph(nodes);`
	`601`	`+ return ImageJob.ToFramewiseGraph(nodes);`
`602`	`602`	`}`
`603`	`603`
`604`		`- private JsonNode ToFramewiseGraph(ICollection<BuildItemBase> uniqueNodes)`
	`604`	`+ private static JsonNode ToFramewiseGraph(ICollection<BuildItemBase> uniqueNodes)`
`605`	`605`	`{`
`606`	`606`	`var lowestUid = LowestUid(uniqueNodes) ?? 0;`
`607`	`607`	`var edges = CollectEdges(uniqueNodes)`
`@@ -707,7 +707,7 @@ public static async Task<ImageInfo> GetImageInfo(IBytesSource image, Cancellatio`
`707`	`707`	`{`
`708`	`708`	`try`
`709`	`709`	`{`
`710`		`- var inputByteArray = await image.GetBytesAsync(cancellationToken);`
	`710`	`+ var inputByteArray = await image.GetBytesAsync(cancellationToken).ConfigureAwait(false);`
`711`	`711`	`using (var ctx = new JobContext())`
`712`	`712`	`{`
`713`	`713`	`ctx.AddInputBytesPinned(0, inputByteArray);`
`@@ -758,7 +758,7 @@ public static async ValueTask<ImageInfo> GetImageInfoAsync(IAsyncMemorySource im`
`758`	`758`	`{`
`759`	`759`	`try`
`760`	`760`	`{`
`761`		`- var inputMemory = await image.BorrowReadOnlyMemoryAsync(cancellationToken);`
	`761`	`+ var inputMemory = await image.BorrowReadOnlyMemoryAsync(cancellationToken).ConfigureAwait(false);`
`762`	`762`	`if (inputMemory.Length == 0)`
`763`	`763`	`{`
`764`	`764`	`throw new ArgumentException("Input image is empty");`
`@@ -782,7 +782,7 @@ public static async ValueTask<ImageInfo> GetImageInfoAsync(IAsyncMemorySource im`
`782`	`782`	`}`
`783`	`783`	`}`
`784`	`784`	`/// <summary>`
`785`		`- /// Returns true if it is likely that Imageflow can decode the given image based on the first 12 bytes of the file.`
	`785`	`+ /// Returns true if it is likely that Imageflow can decode the given image based on the first 12 bytes of the file.`
`786`	`786`	`/// </summary>`
`787`	`787`	`/// <param name="first12Bytes">The first 12 or more bytes of the file</param>`
`788`	`788`	`/// <returns></returns>`
`@@ -795,7 +795,7 @@ public static bool CanDecodeBytes(byte[] first12Bytes)`
`795`	`795`	`/// <summary>`
`796`	`796`	`/// Returns a MIME type string such as "image/jpeg" based on the provided first 12 bytes of the file.`
`797`	`797`	`/// Only guaranteed to work for image types Imageflow supports, but support for more file types may be added`
`798`		`- /// later.`
	`798`	`+ /// later.`
`799`	`799`	`/// </summary>`
`800`	`800`	`/// <param name="first12Bytes">The first 12 or more bytes of the file</param>`
`801`	`801`	`/// <returns></returns>`
Original file line number	Diff line number	Diff line change
`@@ -2,5 +2,5 @@ namespace Imageflow.Fluent;`
`2`	`2`
`3`	`3`	`internal class JobExecutionOptions`
`4`	`4`	`{`
`5`		`- internal bool OffloadCpuToThreadPool { get; set; } = false;`
	`5`	`+ internal bool OffloadCpuToThreadPool { get; set; }`
`6`	`6`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ public sealed class MemorySource : IAsyncMemorySource, IMemorySource`
`11`	`11`
`12`	`12`	`public static IAsyncMemorySource TakeOwnership(IMemoryOwner<byte> ownedMemory, MemoryLifetimePromise promise)`
`13`	`13`	`{`
`14`		`- ArgumentNullThrowHelper.ThrowIfNull(ownedMemory);`
	`14`	`+ Argument.ThrowIfNull(ownedMemory);`
`15`	`15`	`if (promise != MemoryLifetimePromise.MemoryOwnerDisposedByMemorySource)`
`16`	`16`	`{`
`17`	`17`	`throw new ArgumentException(`
`@@ -26,7 +26,7 @@ private MemorySource(ReadOnlyMemory<byte>? borrowedMemory, IMemoryOwner<byte>? o`
`26`	`26`	`{`
`27`	`27`	`if (promise == MemoryLifetimePromise.MemoryOwnerDisposedByMemorySource)`
`28`	`28`	`{`
`29`		`- ArgumentNullThrowHelper.ThrowIfNull(ownedMemory);`
	`29`	`+ Argument.ThrowIfNull(ownedMemory);`
`30`	`30`	`if (borrowedMemory.HasValue)`
`31`	`31`	`{`
`32`	`32`	`throw new ArgumentException(`
`@@ -39,7 +39,7 @@ private MemorySource(ReadOnlyMemory<byte>? borrowedMemory, IMemoryOwner<byte>? o`
`39`	`39`	`throw new ArgumentNullException(nameof(borrowedMemory));`
`40`	`40`	`}`
`41`	`41`
`42`		`- ArgumentNullThrowHelper.ThrowIfNull(borrowedMemory);`
	`42`	`+ Argument.ThrowIfNull(borrowedMemory);`
`43`	`43`	`_borrowedMemory = borrowedMemory;`
`44`	`44`	`_ownedMemory = ownedMemory;`
`45`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ public string GetFirstFrameSummary()`
`43`	`43`	`foreach (var n in Frames.First().Nodes)`
`44`	`44`	`{`
`45`	`45`	`sb.Append(n.Name);`
`46`		`- sb.Append("(");`
	`46`	`+ sb.Append('(');`
`47`	`47`	`sb.Append((n.WallMicroseconds / 1000.0).ToString("0.####"));`
`48`	`48`	`sb.Append("ms) ");`
`49`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ public async Task<ArraySegment<byte>> GetBytesAsync(CancellationToken cancellati`
`51`	`51`	`if (_copy == null)`
`52`	`52`	`{`
`53`	`53`	`_copy = new RecyclableMemoryStream(Mgr, "StreamSource: IBytesSource", length);`
`54`		`- await underlying.CopyToAsync(_copy, 81920, cancellationToken);`
	`54`	`+ await underlying.CopyToAsync(_copy, 81920, cancellationToken).ConfigureAwait(false);`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`return new ArraySegment<byte>(_copy.GetBuffer(), 0,`