Refactor

Author: Tyrrrz

YoutubeDownloader.Core/Downloading/FFmpeg.cs

@@ -3,12 +3,12 @@
 using System.IO;
 using System.IO.Compression;
 using System.Linq;
-using System.Net.Http;
 using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 using Gress;
 using YoutubeDownloader.Core.Utils;
+using YoutubeDownloader.Core.Utils.Extensions;
 
 namespace YoutubeDownloader.Core.Downloading;
 
@@ -120,36 +120,12 @@ public static async Task DownloadAsync(
 
         try
         {
-            using var response = await Http.Client.GetAsync(
+            await Http.Client.DownloadAsync(
                 GetDownloadUrl(),
-                HttpCompletionOption.ResponseHeadersRead,
+                archiveFilePath,
+                progress,
                 cancellationToken
             );
-            response.EnsureSuccessStatusCode();
-
-            var totalSize = response.Content.Headers.ContentLength;
-            var downloadedSize = 0L;
-            var buffer = new byte[81920];
-
-            await using var responseStream = await response.Content.ReadAsStreamAsync(
-                cancellationToken
-            );
-            await using (var archiveFile = File.Create(archiveFilePath))
-            {
-                int bytesRead;
-                while ((bytesRead = await responseStream.ReadAsync(buffer, cancellationToken)) > 0)
-                {
-                    await archiveFile.WriteAsync(buffer.AsMemory(0, bytesRead), cancellationToken);
-                    downloadedSize += bytesRead;
-
-                    if (totalSize > 0)
-                    {
-                        progress?.Report(
-                            Percentage.FromFraction((double)downloadedSize / totalSize.Value)
-                        );
-                    }
-                }
-            }
 
             using var zip = ZipFile.OpenRead(archiveFilePath);
             var entry =

YoutubeDownloader.Core/Utils/Extensions/HttpExtensions.cs

@@ -0,0 +1,36 @@
+using System;
+using System.IO;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Gress;
+
+namespace YoutubeDownloader.Core.Utils.Extensions;
+
+public static class HttpExtensions
+{
+    extension(HttpClient http)
+    {
+        public async Task DownloadAsync(
+            string url,
+            string filePath,
+            IProgress<Percentage>? progress = null,
+            CancellationToken cancellationToken = default
+        )
+        {
+            using var response = await http.GetAsync(
+                url,
+                HttpCompletionOption.ResponseHeadersRead,
+                cancellationToken
+            );
+
+            response.EnsureSuccessStatusCode();
+
+            await using var source = await response.Content.ReadAsStreamAsync(cancellationToken);
+            await using var destination = File.Create(filePath);
+
+            var totalBytes = response.Content.Headers.ContentLength ?? -1L;
+            await source.CopyToAsync(destination, totalBytes, progress, cancellationToken);
+        }
+    }
+}

YoutubeDownloader.Core/Utils/Extensions/StreamExtensions.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Buffers;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using Gress;
+
+namespace YoutubeDownloader.Core.Utils.Extensions;
+
+public static class StreamExtensions
+{
+    extension(Stream stream)
+    {
+        public async Task<int> CopyBufferedToAsync(
+            Stream destination,
+            Memory<byte> buffer,
+            CancellationToken cancellationToken = default
+        )
+        {
+            var bytesCopied = await stream.ReadAsync(buffer, cancellationToken);
+            await destination.WriteAsync(buffer[..bytesCopied], cancellationToken);
+
+            return bytesCopied;
+        }
+
+        public async Task CopyToAsync(
+            Stream destination,
+            long totalBytes,
+            IProgress<Percentage>? progress = null,
+            CancellationToken cancellationToken = default
+        )
+        {
+            using var buffer = MemoryPool<byte>.Shared.Rent(81920);
+
+            var totalBytesCopied = 0L;
+            int bytesCopied;
+            do
+            {
+                bytesCopied = await stream.CopyBufferedToAsync(
+                    destination,
+                    buffer.Memory,
+                    cancellationToken
+                );
+
+                totalBytesCopied += bytesCopied;
+
+                if (totalBytes > 0)
+                    progress?.Report(Percentage.FromFraction(1.0 * totalBytesCopied / totalBytes));
+            } while (bytesCopied > 0);
+        }
+    }
+}