fixes

Author: KSemenenko

.github/workflows/ci.yml

@@ -10,8 +10,8 @@ env:
   DOTNET_VERSION: '10.0.x'
 
 jobs:
-  build:
-    name: Build and Test
+  build-and-test:
+    name: build-and-test
     runs-on: ubuntu-latest
 
     steps:

AGENTS.md

@@ -142,6 +142,7 @@ If no new rule is detected → do not update the file.
 - Nullability is enabled: annotate optional members; avoid `!` unless justified
 - Suffix async APIs with `Async`; keep test names aligned with existing patterns (e.g., `DownloadFile_WhenFileExists_ReturnsSuccess`)
 - Remove unused usings and let analyzers guide layout
+- When a `foreach` loop’s first step is just transforming the iteration variable (e.g., `var y = Map(x)`), prefer mapping the sequence explicitly with `.Select(...)` so intent is clearer and analyzers stay quiet
 - No magic literals — extract to constants, enums, or config when it improves clarity
 
 ### Git & PRs
@@ -150,6 +151,7 @@ If no new rule is detected → do not update the file.
 - Group related edits in one commit and avoid WIP spam
 - PRs should summarize impact, list touched projects, reference issues, and note new configuration or secrets
 - Include the `dotnet` commands you ran and add logs when CI needs context
+- Keep a required CI check named `build-and-test` running on every PR and push to `main` so branch protection always receives a status (it’s worse for merges if the check is missing/never reported than if it runs and fails)
 
 ### Critical (NEVER violate)
 

Integraions/ManagedCode.Storage.Client/StorageClient.cs

@@ -45,7 +45,7 @@ public async Task<Result<BlobMetadata>> UploadFile(Stream stream, string apiUrl,
         using var formData = new MultipartFormDataContent();
         formData.Add(streamContent, contentName, contentName);
 
-        var response = await httpClient.PostAsync(apiUrl, formData, cancellationToken);
+        using var response = await httpClient.PostAsync(apiUrl, formData, cancellationToken);
 
         if (response.IsSuccessStatusCode)
             return await response.Content.ReadFromJsonAsync<Result<BlobMetadata>>(cancellationToken: cancellationToken);
@@ -63,7 +63,7 @@ public async Task<Result<BlobMetadata>> UploadFile(FileInfo fileInfo, string api
         {
             formData.Add(streamContent, contentName, contentName);
 
-            var response = await httpClient.PostAsync(apiUrl, formData, cancellationToken);
+            using var response = await httpClient.PostAsync(apiUrl, formData, cancellationToken);
 
             if (response.IsSuccessStatusCode)
             {
@@ -77,27 +77,21 @@ public async Task<Result<BlobMetadata>> UploadFile(FileInfo fileInfo, string api
 
     public async Task<Result<BlobMetadata>> UploadFile(byte[] bytes, string apiUrl, string contentName, CancellationToken cancellationToken = default)
     {
-        using (var stream = new MemoryStream())
-        {
-            stream.Write(bytes, 0, bytes.Length);
-
-            using var streamContent = new StreamContent(stream);
-
-            using (var formData = new MultipartFormDataContent())
-            {
-                formData.Add(streamContent, contentName, contentName);
+        using var stream = new MemoryStream(bytes, writable: false);
+        using var streamContent = new StreamContent(stream);
+        using var formData = new MultipartFormDataContent();
 
-                var response = await httpClient.PostAsync(apiUrl, formData, cancellationToken);
+        formData.Add(streamContent, contentName, contentName);
 
-                if (response.IsSuccessStatusCode)
-                {
-                    var result = await response.Content.ReadFromJsonAsync<Result<BlobMetadata>>(cancellationToken: cancellationToken);
-                    return result;
-                }
+        using var response = await httpClient.PostAsync(apiUrl, formData, cancellationToken);
 
-                return Result<BlobMetadata>.Fail(response.StatusCode);
-            }
+        if (response.IsSuccessStatusCode)
+        {
+            var result = await response.Content.ReadFromJsonAsync<Result<BlobMetadata>>(cancellationToken: cancellationToken);
+            return result;
         }
+
+        return Result<BlobMetadata>.Fail(response.StatusCode);
     }
 
     public async Task<Result<BlobMetadata>> UploadFile(string base64, string apiUrl, string contentName,
@@ -110,7 +104,7 @@ public async Task<Result<BlobMetadata>> UploadFile(string base64, string apiUrl,
 
         formData.Add(fileContent, contentName, contentName);
 
-        var response = await httpClient.PostAsync(apiUrl, formData, cancellationToken);
+        using var response = await httpClient.PostAsync(apiUrl, formData, cancellationToken);
 
         if (response.IsSuccessStatusCode)
             return await response.Content.ReadFromJsonAsync<Result<BlobMetadata>>(cancellationToken: cancellationToken);
@@ -188,11 +182,13 @@ public async Task<Result<uint>> UploadLargeFile(Stream file, string uploadApiUrl
             formData.Add(new StringContent(bytesRead.ToString()), "Payload.ChunkSize");
             formData.Add(new StringContent(totalChunks.ToString()), "Payload.TotalChunks");
 
-            var response = await httpClient.PostAsync(uploadApiUrl, formData, cancellationToken);
-            if (!response.IsSuccessStatusCode)
+            using (var response = await httpClient.PostAsync(uploadApiUrl, formData, cancellationToken))
             {
-                var message = await response.Content.ReadAsStringAsync(cancellationToken);
-                return Result<uint>.Fail(response.StatusCode, message);
+                if (!response.IsSuccessStatusCode)
+                {
+                    var message = await response.Content.ReadAsStringAsync(cancellationToken);
+                    return Result<uint>.Fail(response.StatusCode, message);
+                }
             }
 
             transmitted += bytesRead;
@@ -230,7 +226,7 @@ public async Task<Result<uint>> UploadLargeFile(Stream file, string uploadApiUrl
             KeepMergedFile = false
         };
 
-        var mergeResult = await httpClient.PostAsJsonAsync(completeApiUrl, completePayload, cancellationToken);
+        using var mergeResult = await httpClient.PostAsJsonAsync(completeApiUrl, completePayload, cancellationToken);
         if (!mergeResult.IsSuccessStatusCode)
         {
             var message = await mergeResult.Content.ReadAsStringAsync(cancellationToken);
@@ -308,14 +304,25 @@ public async Task<Result<Stream>> GetFileStream(string fileName, string apiUrl,
     {
         try
         {
-            var response = await httpClient.GetAsync($"{apiUrl}/{fileName}");
-            if (response.IsSuccessStatusCode)
+            var response = await httpClient.GetAsync($"{apiUrl}/{fileName}", HttpCompletionOption.ResponseHeadersRead, cancellationToken);
+            if (!response.IsSuccessStatusCode)
+            {
+                response.Dispose();
+                return Result<Stream>.Fail(response.StatusCode);
+            }
+
+            Stream contentStream;
+            try
+            {
+                contentStream = await response.Content.ReadAsStreamAsync(cancellationToken);
+            }
+            catch
             {
-                var stream = await response.Content.ReadAsStreamAsync();
-                return Result<Stream>.Succeed(stream);
+                response.Dispose();
+                throw;
             }
 
-            return Result<Stream>.Fail(response.StatusCode);
+            return Result<Stream>.Succeed(new HttpResponseMessageStream(contentStream, response));
         }
         catch (HttpRequestException e) when (e.StatusCode != null)
         {
@@ -328,6 +335,82 @@ public async Task<Result<Stream>> GetFileStream(string fileName, string apiUrl,
     }
 }
 
+file sealed class HttpResponseMessageStream(Stream innerStream, HttpResponseMessage response) : Stream
+{
+    private readonly Stream _innerStream = innerStream ?? throw new ArgumentNullException(nameof(innerStream));
+    private readonly HttpResponseMessage _response = response ?? throw new ArgumentNullException(nameof(response));
+
+    public override bool CanRead => _innerStream.CanRead;
+    public override bool CanSeek => _innerStream.CanSeek;
+    public override bool CanWrite => _innerStream.CanWrite;
+    public override long Length => _innerStream.Length;
+
+    public override long Position
+    {
+        get => _innerStream.Position;
+        set => _innerStream.Position = value;
+    }
+
+    public override void Flush() => _innerStream.Flush();
+
+    public override Task FlushAsync(CancellationToken cancellationToken) => _innerStream.FlushAsync(cancellationToken);
+
+    public override int Read(byte[] buffer, int offset, int count) => _innerStream.Read(buffer, offset, count);
+
+    public override int Read(Span<byte> buffer) => _innerStream.Read(buffer);
+
+    public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) =>
+        _innerStream.ReadAsync(buffer, offset, count, cancellationToken);
+
+    public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default) =>
+        _innerStream.ReadAsync(buffer, cancellationToken);
+
+    public override long Seek(long offset, SeekOrigin origin) => _innerStream.Seek(offset, origin);
+
+    public override void SetLength(long value) => _innerStream.SetLength(value);
+
+    public override void Write(byte[] buffer, int offset, int count) => _innerStream.Write(buffer, offset, count);
+
+    public override void Write(ReadOnlySpan<byte> buffer) => _innerStream.Write(buffer);
+
+    public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) =>
+        _innerStream.WriteAsync(buffer, offset, count, cancellationToken);
+
+    public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default) =>
+        _innerStream.WriteAsync(buffer, cancellationToken);
+
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+        {
+            try
+            {
+                _innerStream.Dispose();
+            }
+            finally
+            {
+                _response.Dispose();
+            }
+        }
+
+        base.Dispose(disposing);
+    }
+
+    public override async ValueTask DisposeAsync()
+    {
+        try
+        {
+            await _innerStream.DisposeAsync();
+        }
+        finally
+        {
+            _response.Dispose();
+        }
+
+        await base.DisposeAsync();
+    }
+}
+
 file class ChunkUploadCompleteRequestDto
 {
     public string UploadId { get; set; } = string.Empty;

ManagedCode.Storage.Core/BaseStorage.cs

@@ -110,23 +110,25 @@ public Task<Result<BlobMetadata>> UploadAsync(Stream stream, UploadOptions optio
         return UploadInternalAsync(stream, SetUploadOptions(options), cancellationToken);
     }
 
-    public Task<Result<BlobMetadata>> UploadAsync(byte[] data, UploadOptions options, CancellationToken cancellationToken = default)
+    public async Task<Result<BlobMetadata>> UploadAsync(byte[] data, UploadOptions options, CancellationToken cancellationToken = default)
     {
         if (string.IsNullOrWhiteSpace(options.MimeType))
             options.MimeType = MimeHelper.GetMimeType(options.FileName);
 
-        return UploadInternalAsync(new MemoryStream(data), SetUploadOptions(options), cancellationToken);
+        using var stream = new MemoryStream(data, writable: false);
+        return await UploadInternalAsync(stream, SetUploadOptions(options), cancellationToken);
     }
 
-    public Task<Result<BlobMetadata>> UploadAsync(string content, UploadOptions options, CancellationToken cancellationToken = default)
+    public async Task<Result<BlobMetadata>> UploadAsync(string content, UploadOptions options, CancellationToken cancellationToken = default)
     {
         if (string.IsNullOrWhiteSpace(options.MimeType))
             options.MimeType = MimeHelper.TEXT;
 
-        return UploadInternalAsync(new Utf8StringStream(content), SetUploadOptions(options), cancellationToken);
+        using var stream = new Utf8StringStream(content);
+        return await UploadInternalAsync(stream, SetUploadOptions(options), cancellationToken);
     }
 
-    public Task<Result<BlobMetadata>> UploadAsync(FileInfo fileInfo, UploadOptions options, CancellationToken cancellationToken = default)
+    public async Task<Result<BlobMetadata>> UploadAsync(FileInfo fileInfo, UploadOptions options, CancellationToken cancellationToken = default)
     {
         if (string.IsNullOrWhiteSpace(options.MimeType))
             options.MimeType = MimeHelper.GetMimeType(fileInfo.Extension);
@@ -136,7 +138,8 @@ public Task<Result<BlobMetadata>> UploadAsync(FileInfo fileInfo, UploadOptions o
             options.FileName = fileInfo.Name;
         }
 
-        return UploadInternalAsync(fileInfo.OpenRead(), SetUploadOptions(options), cancellationToken);
+        using var stream = fileInfo.OpenRead();
+        return await UploadInternalAsync(stream, SetUploadOptions(options), cancellationToken);
     }
 
     public Task<Result<LocalFile>> DownloadAsync(string fileName, CancellationToken cancellationToken = default)
@@ -336,4 +339,4 @@ public void Dispose()
         if (StorageClient is IDisposable disposable)
             disposable.Dispose();
     }
-}
+}

Storages/ManagedCode.Storage.Azure/AzureStorage.cs

@@ -204,9 +204,8 @@ protected override async Task<Result> DeleteDirectoryInternalAsync(string direct
         {
             var blobs = StorageClient.GetBlobs(prefix: directory, cancellationToken: cancellationToken);
 
-            foreach (var blob in blobs)
+            foreach (var blobClient in blobs.Select(blob => StorageClient.GetBlobClient(blob.Name)))
             {
-                var blobClient = StorageClient.GetBlobClient(blob.Name);
                 await blobClient.DeleteIfExistsAsync(DeleteSnapshotsOption.None, null, cancellationToken);
             }
 

Tests/ManagedCode.Storage.Tests/AspNetTests/CrossProvider/CrossProviderSyncTests.cs

@@ -42,10 +42,11 @@ public async Task SyncBlobAcrossProviders_PreservesPayloadAndMetadata(string sou
         await EnsureContainerAsync(sourceStorage);
         await EnsureContainerAsync(targetStorage);
 
-        var payload = new byte[256 * 1024];
-        RandomNumberGenerator.Fill(payload);
+	        var payload = new byte[256 * 1024];
+	        RandomNumberGenerator.Fill(payload);
 
-        var expectedCrc = Crc32Helper.CalculateStreamCrc(new MemoryStream(payload, writable: false));
+	        using var crcStream = new MemoryStream(payload, writable: false);
+	        var expectedCrc = Crc32Helper.CalculateStreamCrc(crcStream);
 
         var directory = $"sync-tests/{Guid.NewGuid():N}";
         var fileName = $"payload-{Guid.NewGuid():N}.bin";

Tests/ManagedCode.Storage.Tests/Common/FileHelper.cs

@@ -1,6 +1,8 @@
 using System;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using ManagedCode.MimeTypes;
 using ManagedCode.Storage.Core.Models;
 using Microsoft.AspNetCore.Http;
@@ -65,18 +67,17 @@ public static LocalFile GenerateLocalFileWithData(LocalFile file, int sizeInByte
     public static IFormFile GenerateFormFile(string fileName, int byteSize)
     {
         var localFile = GenerateLocalFile(fileName, byteSize);
+        var contentType = MimeHelper.GetMimeType(localFile.FileInfo.Extension);
 
-        var ms = new MemoryStream();
-        localFile.FileStream.CopyTo(ms);
-        var formFile = new FormFile(ms, 0, ms.Length, fileName, fileName)
+        byte[] bytes;
+        using (localFile)
         {
-            Headers = new HeaderDictionary(),
-            ContentType = MimeHelper.GetMimeType(localFile.FileInfo.Extension)
-        };
-
-        localFile.Dispose();
+            using var ms = new MemoryStream();
+            localFile.FileStream.CopyTo(ms);
+            bytes = ms.ToArray();
+        }
 
-        return formFile;
+        return new InMemoryFormFile(bytes, fileName, fileName, contentType);
     }
 
     public static string GenerateRandomFileName()
@@ -94,4 +95,47 @@ public static string GenerateRandomFileContent(int charCount = 250_000)
             .Select(s => s[Random.Next(s.Length)])
             .ToArray());
     }
+
+    private sealed class InMemoryFormFile : IFormFile
+    {
+        private readonly byte[] _content;
+
+        public InMemoryFormFile(byte[] content, string name, string fileName, string contentType)
+        {
+            _content = content;
+            Name = name;
+            FileName = fileName;
+            ContentType = contentType;
+            Headers = new HeaderDictionary
+            {
+                { "Content-Type", contentType }
+            };
+            ContentDisposition = $"form-data; name=\"{name}\"; filename=\"{fileName}\"";
+        }
+
+        public string ContentType { get; }
+        public string ContentDisposition { get; }
+        public IHeaderDictionary Headers { get; }
+        public long Length => _content.Length;
+        public string Name { get; }
+        public string FileName { get; }
+
+        public Stream OpenReadStream() => new MemoryStream(_content, writable: false);
+
+        public void CopyTo(Stream target)
+        {
+            ArgumentNullException.ThrowIfNull(target);
+
+            using var stream = OpenReadStream();
+            stream.CopyTo(target);
+        }
+
+        public async Task CopyToAsync(Stream target, CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(target);
+
+            await using var stream = OpenReadStream();
+            await stream.CopyToAsync(target, cancellationToken);
+        }
+    }
 }