Add extensions for Stream, HttpContent, HttpClient that make use of progress reporting

Directory.Packages.props

@@ -2,7 +2,6 @@
   <PropertyGroup>
     <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
   </PropertyGroup>
-
   <ItemGroup>
     <PackageVersion Include="Avalonia" Version="11.3.14" />
     <PackageVersion Include="Avalonia.Desktop" Version="11.3.14" />
@@ -15,8 +14,8 @@
     <PackageVersion Include="FluentAssertions" Version="8.9.0" />
     <PackageVersion Include="GitHubActionsTestLogger" Version="3.0.2" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.3.0" />
-    <PackageVersion Include="PolyShim" Version="2.9.0" />
-    <PackageVersion Include="PowerKit" Version="0.0.0-a.3" />
+    <PackageVersion Include="PolyShim" Version="2.11.0-a.3" />
+    <PackageVersion Include="PowerKit" Version="1.1.1" />
     <PackageVersion Include="xunit" Version="2.9.3" />
     <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
   </ItemGroup>

Gress.Tests/Gress.Tests.csproj

@@ -11,6 +11,7 @@
     <PackageReference Include="coverlet.collector" PrivateAssets="all" />
     <PackageReference Include="CSharpier.MsBuild" PrivateAssets="all" />
     <PackageReference Include="FluentAssertions" />
+    <PackageReference Include="PowerKit" PrivateAssets="all" />
     <PackageReference Include="GitHubActionsTestLogger" PrivateAssets="all" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" />
     <PackageReference Include="xunit" />

Gress.Tests/IntegrationSpecs.cs

@@ -0,0 +1,102 @@
+using System;
+using System.IO;
+using System.Net.Http;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Gress.Integration;
+using PowerKit;
+using PowerKit.Extensions;
+using Xunit;
+
+namespace Gress.Tests;
+
+public class IntegrationSpecs
+{
+    [Fact]
+    public async Task I_can_copy_a_stream_to_another_stream_with_progress()
+    {
+        // Arrange
+        using var buffer = SpanPool<byte>.Shared.Rent(
+            // Longer buffer to ensure multiple progress reports
+            81920 * 2
+                + 1000
+        );
+
+        Random.Shared.NextBytes(buffer.Span);
+        var data = buffer.Span.ToArray();
+
+        using var source = new MemoryStream(data);
+        using var destination = new MemoryStream();
+        var progress = new ProgressCollector<Percentage>();
+
+        // Act
+        await source.CopyToAsync(destination, progress);
+
+        // Assert
+        destination.ToArray().Should().Equal(data);
+        progress.GetValues().Should().NotBeEmpty();
+        progress.GetValues().Should().BeInAscendingOrder();
+    }
+
+    [Fact]
+    public async Task I_can_download_a_web_resource_as_a_byte_array_with_progress()
+    {
+        // Arrange
+        using var http = new HttpClient();
+        var progress = new ProgressCollector<Percentage>();
+
+        // Act
+        var result = await http.GetByteArrayAsync(
+            // Need something that reports content length
+            "https://github.com/Tyrrrz/CliWrap/releases/download/3.10.1/CliWrap.3.10.1.nupkg",
+            progress
+        );
+
+        // Assert
+        result.Should().NotBeNullOrEmpty();
+        progress.GetValues().Should().NotBeEmpty();
+    }
+
+    [Fact]
+    public async Task I_can_download_a_web_resource_as_a_string_with_progress()
+    {
+        // Arrange
+        using var http = new HttpClient();
+        var progress = new ProgressCollector<Percentage>();
+
+        // Act
+        var result = await http.GetStringAsync(
+            // Need something that reports content length
+            "https://github.com/Tyrrrz/CliWrap/releases/download/3.10.1/CliWrap.3.10.1.nupkg",
+            progress
+        );
+
+        // Assert
+        result.Should().NotBeNullOrEmpty();
+        progress.GetValues().Should().NotBeEmpty();
+    }
+
+    [Fact]
+    public async Task I_can_download_a_web_resource_to_a_file_with_progress()
+    {
+        // Arrange
+        using var http = new HttpClient();
+        using var tempFile = TempFile.Create();
+        var progress = new ProgressCollector<Percentage>();
+
+        // Act
+        await http.DownloadAsync(
+            // Need something that reports content length
+            "https://github.com/Tyrrrz/CliWrap/releases/download/3.10.1/CliWrap.3.10.1.nupkg",
+            tempFile.Path,
+            progress
+        );
+
+        // Assert
+        new FileInfo(tempFile.Path)
+            .Length.Should()
+            .BeGreaterThan(0);
+
+        progress.GetValues().Should().NotBeEmpty();
+    }
+}

Gress/Integration/HttpClientExtensions.cs

@@ -0,0 +1,120 @@
+using System;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using PowerKit.Extensions;
+
+namespace Gress.Integration;
+
+/// <summary>
+/// Provides progress-aware extensions for <see cref="HttpClient" />.
+/// </summary>
+public static class HttpClientExtensions
+{
+    /// <inheritdoc cref="HttpClientExtensions" />
+    extension(HttpClient client)
+    {
+        /// <summary>
+        /// Sends a GET request and returns the response body as a byte array.
+        /// </summary>
+        public async Task<byte[]> GetByteArrayAsync(
+            Uri requestUri,
+            IProgress<Percentage>? progress,
+            CancellationToken cancellationToken = default
+        )
+        {
+            using var response = await client
+                .GetAsync(requestUri, HttpCompletionOption.ResponseHeadersRead, cancellationToken)
+                .ConfigureAwait(false);
+
+            response.EnsureSuccessStatusCode();
+
+            return await response
+                .Content.ReadAsByteArrayAsync(progress, cancellationToken)
+                .ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Sends a GET request and returns the response body as a byte array.
+        /// </summary>
+        public async Task<byte[]> GetByteArrayAsync(
+            string requestUri,
+            IProgress<Percentage>? progress,
+            CancellationToken cancellationToken = default
+        ) =>
+            await client
+                .GetByteArrayAsync(
+                    new Uri(requestUri, UriKind.RelativeOrAbsolute),
+                    progress,
+                    cancellationToken
+                )
+                .ConfigureAwait(false);
+
+        /// <summary>
+        /// Sends a GET request and returns the response body as text.
+        /// </summary>
+        public async Task<string> GetStringAsync(
+            Uri requestUri,
+            IProgress<Percentage>? progress,
+            CancellationToken cancellationToken = default
+        )
+        {
+            using var response = await client
+                .GetAsync(requestUri, HttpCompletionOption.ResponseHeadersRead, cancellationToken)
+                .ConfigureAwait(false);
+
+            response.EnsureSuccessStatusCode();
+
+            return await response
+                .Content.ReadAsStringAsync(progress, cancellationToken)
+                .ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Sends a GET request and returns the response body as text.
+        /// </summary>
+        public async Task<string> GetStringAsync(
+            string requestUri,
+            IProgress<Percentage>? progress,
+            CancellationToken cancellationToken = default
+        ) =>
+            await client
+                .GetStringAsync(
+                    new Uri(requestUri, UriKind.RelativeOrAbsolute),
+                    progress,
+                    cancellationToken
+                )
+                .ConfigureAwait(false);
+
+        /// <summary>
+        /// Sends a GET request and saves the response body to a file.
+        /// </summary>
+        public async Task DownloadAsync(
+            Uri requestUri,
+            string filePath,
+            IProgress<Percentage>? progress,
+            CancellationToken cancellationToken = default
+        ) =>
+            await client
+                .DownloadAsync(requestUri, filePath, progress?.ToDoubleBased(), cancellationToken)
+                .ConfigureAwait(false);
+
+        /// <summary>
+        /// Sends a GET request and saves the response body to a file.
+        /// </summary>
+        public async Task DownloadAsync(
+            string requestUri,
+            string filePath,
+            IProgress<Percentage>? progress,
+            CancellationToken cancellationToken = default
+        ) =>
+            await client
+                .DownloadAsync(
+                    new Uri(requestUri, UriKind.RelativeOrAbsolute),
+                    filePath,
+                    progress,
+                    cancellationToken
+                )
+                .ConfigureAwait(false);
+    }
+}

Gress/Integration/HttpContentExtensions.cs

@@ -0,0 +1,92 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using PowerKit.Extensions;
+
+namespace Gress.Integration;
+
+/// <summary>
+/// Provides progress-aware extensions for <see cref="HttpContent" />.
+/// </summary>
+public static class HttpContentExtensions
+{
+    /// <inheritdoc cref="HttpContentExtensions" />
+    extension(HttpContent content)
+    {
+        /// <summary>
+        /// Serializes the HTTP content and writes it to the specified stream.
+        /// </summary>
+        public async Task CopyToAsync(
+            Stream destination,
+            IProgress<Percentage>? progress,
+            CancellationToken cancellationToken = default
+        ) =>
+            await content
+                .CopyToStreamAsync(destination, progress?.ToDoubleBased(), cancellationToken)
+                .ConfigureAwait(false);
+
+        private async Task<MemoryStream> ReadAsMemoryStreamAsync(
+            IProgress<Percentage>? progress,
+            CancellationToken cancellationToken = default
+        )
+        {
+            var destination = new MemoryStream();
+
+            await content
+                .CopyToAsync(destination, progress, cancellationToken)
+                .ConfigureAwait(false);
+
+            destination.Position = 0;
+
+            return destination;
+        }
+
+        /// <summary>
+        /// Reads the HTTP content and returns it as a byte array.
+        /// </summary>
+        public async Task<byte[]> ReadAsByteArrayAsync(
+            IProgress<Percentage>? progress,
+            CancellationToken cancellationToken = default
+        )
+        {
+            using var buffer = await content
+                .ReadAsMemoryStreamAsync(progress, cancellationToken)
+                .ConfigureAwait(false);
+
+            return buffer.ToArray();
+        }
+
+        /// <summary>
+        /// Reads the HTTP content and returns it as a string.
+        /// </summary>
+        public async Task<string> ReadAsStringAsync(
+            IProgress<Percentage>? progress,
+            CancellationToken cancellationToken = default
+        )
+        {
+            var encoding =
+                content
+                    .Headers.ContentType?.CharSet?.Pipe(c =>
+                        Encoding
+                            .GetEncodings()
+                            .FirstOrDefault(e =>
+                                string.Equals(e.Name, c, StringComparison.OrdinalIgnoreCase)
+                            )
+                    )
+                    ?.GetEncoding()
+                ?? Encoding.UTF8;
+
+            using var buffer = await content
+                .ReadAsMemoryStreamAsync(progress, cancellationToken)
+                .ConfigureAwait(false);
+
+            using var reader = new StreamReader(buffer, encoding, true);
+
+            return await reader.ReadToEndAsync(cancellationToken).ConfigureAwait(false);
+        }
+    }
+}

Gress/Integration/StreamExtensions.cs

@@ -0,0 +1,52 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using PowerKit.Extensions;
+
+namespace Gress.Integration;
+
+/// <summary>
+/// Provides progress-aware extensions for <see cref="Stream" />.
+/// </summary>
+public static class StreamExtensions
+{
+    /// <inheritdoc cref="StreamExtensions" />
+    extension(Stream source)
+    {
+        /// <summary>
+        /// Asynchronously copies bytes from the source stream to the destination stream.
+        /// </summary>
+        public async Task CopyToAsync(
+            Stream destination,
+            long sourceLength,
+            IProgress<Percentage>? progress,
+            CancellationToken cancellationToken = default
+        ) =>
+            await source
+                .CopyToAsync(
+                    destination,
+                    sourceLength,
+                    progress?.ToDoubleBased(),
+                    cancellationToken
+                )
+                .ConfigureAwait(false);
+
+        /// <summary>
+        /// Asynchronously copies bytes from the source stream to the destination stream.
+        /// </summary>
+        public async Task CopyToAsync(
+            Stream destination,
+            IProgress<Percentage>? progress,
+            CancellationToken cancellationToken = default
+        ) =>
+            await source
+                .CopyToAsync(
+                    destination,
+                    source.CanSeek ? source.Length : -1,
+                    progress,
+                    cancellationToken
+                )
+                .ConfigureAwait(false);
+    }
+}