diff --git a/src/Downloader/ConcurrentStream.cs b/src/Downloader/ConcurrentStream.cs
index 520f587..1a1eec9 100644
--- a/src/Downloader/ConcurrentStream.cs
+++ b/src/Downloader/ConcurrentStream.cs
@@ -6,7 +6,10 @@
 
 namespace Downloader;
 
-public class ConcurrentStream : TaskStateManagement, IDisposable
+/// <summary>
+/// Represents a stream that supports concurrent read and write operations with optional memory buffering.
+/// </summary>
+public class ConcurrentStream : TaskStateManagement, IDisposable, IAsyncDisposable
 {
     private ConcurrentPacketBuffer<Packet> _inputBuffer;
     private volatile bool _disposed;
@@ -14,6 +17,9 @@ public class ConcurrentStream : TaskStateManagement, IDisposable
     private string _path;
     private CancellationTokenSource _watcherCancelSource;
 
+    /// <summary>
+    /// Gets or sets the path of the file associated with the stream.
+    /// </summary>
     public string Path
     {
         get => _path;
@@ -26,6 +32,10 @@ public string Path
             }
         }
     }
+
+    /// <summary>
+    /// Gets the data of the stream as a byte array if the stream is a MemoryStream.
+    /// </summary>
     public byte[] Data
     {
         get
@@ -49,38 +59,86 @@ public byte[] Data
             }
         }
     }
+
+    /// <summary>
+    /// Gets a value indicating whether the stream supports reading.
+    /// </summary>
     public bool CanRead => _stream?.CanRead == true;
+
+    /// <summary>
+    /// Gets a value indicating whether the stream supports seeking.
+    /// </summary>
     public bool CanSeek => _stream?.CanSeek == true;
+
+    /// <summary>
+    /// Gets a value indicating whether the stream supports writing.
+    /// </summary>
     public bool CanWrite => _stream?.CanWrite == true;
+
+    /// <summary>
+    /// Gets the length of the stream in bytes.
+    /// </summary>
     public long Length => _stream?.Length ?? 0;
+
+    /// <summary>
+    /// Gets or sets the current position within the stream.
+    /// </summary>
     public long Position
     {
         get => _stream?.Position ?? 0;
         set => _stream.Position = value;
     }
+
+    /// <summary>
+    /// Gets or sets the maximum amount of memory, in bytes, that the stream is allowed to allocate for buffering.
+    /// </summary>
     public long MaxMemoryBufferBytes
     {
         get => _inputBuffer.BufferSize;
         set => _inputBuffer.BufferSize = value;
     }
 
-    // parameterless constructor for deserialization
-    public ConcurrentStream() : this(0, null) { }
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ConcurrentStream"/> class with default settings.
+    /// </summary>
+    public ConcurrentStream() : this(0) { }
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ConcurrentStream"/> class with the specified logger.
+    /// </summary>
+    /// <param name="logger">The logger to use for logging.</param>
     public ConcurrentStream(ILogger logger) : this(0, logger) { }
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ConcurrentStream"/> class with the specified maximum memory buffer size and logger.
+    /// </summary>
+    /// <param name="maxMemoryBufferBytes">The maximum amount of memory, in bytes, that the stream is allowed to allocate for buffering.</param>
+    /// <param name="logger">The logger to use for logging.</param>
     public ConcurrentStream(long maxMemoryBufferBytes = 0, ILogger logger = null) : base(logger)
     {
         _stream = new MemoryStream();
         Initial(maxMemoryBufferBytes);
     }
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ConcurrentStream"/> class with the specified stream and maximum memory buffer size.
+    /// </summary>
+    /// <param name="stream">The stream to use.</param>
+    /// <param name="maxMemoryBufferBytes">The maximum amount of memory, in bytes, that the stream is allowed to allocate for buffering.</param>
+    /// <param name="logger">The logger to use for logging.</param>
     public ConcurrentStream(Stream stream, long maxMemoryBufferBytes = 0, ILogger logger = null) : base(logger)
     {
         _stream = stream;
         Initial(maxMemoryBufferBytes);
     }
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ConcurrentStream"/> class with the specified file path, initial size, and maximum memory buffer size.
+    /// </summary>
+    /// <param name="filename">The path of the file to use.</param>
+    /// <param name="initSize">The initial size of the file.</param>
+    /// <param name="maxMemoryBufferBytes">The maximum amount of memory, in bytes, that the stream is allowed to allocate for buffering.</param>
+    /// <param name="logger">The logger to use for logging.</param>
     public ConcurrentStream(string filename, long initSize, long maxMemoryBufferBytes = 0, ILogger logger = null) : base(logger)
     {
         _path = filename;
@@ -92,6 +150,11 @@ public ConcurrentStream(string filename, long initSize, long maxMemoryBufferByte
         Initial(maxMemoryBufferBytes);
     }
 
+    /// <summary>
+    /// Initializes the stream with the specified maximum memory buffer size.
+    /// </summary>
+    /// <param name="maxMemoryBufferBytes">The maximum amount of memory, in bytes, that the stream is allowed to allocate for buffering.</param>
+    /// <param name="logger">The logger to use for logging.</param>
     private void Initial(long maxMemoryBufferBytes, ILogger logger = null)
     {
         _inputBuffer = new ConcurrentPacketBuffer<Packet>(maxMemoryBufferBytes, logger);
@@ -106,18 +169,37 @@ private void Initial(long maxMemoryBufferBytes, ILogger logger = null)
         task.Unwrap();
     }
 
+    /// <summary>
+    /// Opens the stream for reading.
+    /// </summary>
+    /// <returns>The stream for reading.</returns>
     public Stream OpenRead()
     {
         Seek(0, SeekOrigin.Begin);
         return _stream;
     }
 
+    /// <summary>
+    /// Reads a sequence of bytes from the stream and advances the position within the stream by the number of bytes read.
+    /// </summary>
+    /// <param name="buffer">An array of bytes to store the read data.</param>
+    /// <param name="offset">The zero-based byte offset in buffer at which to begin storing the data read from the stream.</param>
+    /// <param name="count">The maximum number of bytes to be read from the stream.</param>
+    /// <returns>The total number of bytes read into the buffer.</returns>
     public int Read(byte[] buffer, int offset, int count)
     {
         var stream = OpenRead();
         return stream.Read(buffer, offset, count);
     }
 
+    /// <summary>
+    /// Writes a sequence of bytes to the stream asynchronously at the specified position.
+    /// </summary>
+    /// <param name="position">The position within the stream to write the data.</param>
+    /// <param name="bytes">The data to write to the stream.</param>
+    /// <param name="length">The number of bytes to write.</param>
+    /// <param name="fireAndForget">A value indicating whether to wait for the write operation to complete.</param>
+    /// <returns>A task that represents the asynchronous write operation.</returns>
     public async Task WriteAsync(long position, byte[] bytes, int length, bool fireAndForget = true)
     {
         if (bytes.Length < length)
@@ -135,6 +217,10 @@ public async Task WriteAsync(long position, byte[] bytes, int length, bool fireA
         }
     }
 
+    /// <summary>
+    /// Watches for incoming packets and writes them to the stream.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous watch operation.</returns>
     private async Task Watcher()
     {
         try
@@ -161,6 +247,12 @@ private async Task Watcher()
         }
     }
 
+    /// <summary>
+    /// Sets the position within the current stream.
+    /// </summary>
+    /// <param name="offset">A byte offset relative to the origin parameter.</param>
+    /// <param name="origin">A value of type SeekOrigin indicating the reference point used to obtain the new position.</param>
+    /// <returns>The new position within the current stream.</returns>
     public long Seek(long offset, SeekOrigin origin)
     {
         if (offset != Position && CanSeek)
@@ -171,11 +263,20 @@ public long Seek(long offset, SeekOrigin origin)
         return Position;
     }
 
+    /// <summary>
+    /// Sets the length of the current stream.
+    /// </summary>
+    /// <param name="value">The desired length of the current stream in bytes.</param>
     public void SetLength(long value)
     {
         _stream.SetLength(value);
     }
 
+    /// <summary>
+    /// Writes a packet to the stream.
+    /// </summary>
+    /// <param name="packet">The packet to write.</param>
+    /// <returns>A task that represents the asynchronous write operation.</returns>
     private async Task WritePacketOnFile(Packet packet)
     {
         // seek with SeekOrigin.Begin is so faster than SeekOrigin.Current
@@ -184,6 +285,10 @@ private async Task WritePacketOnFile(Packet packet)
         packet.Dispose();
     }
 
+    /// <summary>
+    /// Flushes the stream asynchronously.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous flush operation.</returns>
     public async Task FlushAsync()
     {
         await _inputBuffer.WaitToComplete().ConfigureAwait(false);
@@ -196,9 +301,12 @@ public async Task FlushAsync()
         GC.Collect();
     }
 
+    /// <summary>
+    /// Releases the unmanaged resources used by the ConcurrentStream and optionally releases the managed resources.
+    /// </summary>
     public void Dispose()
     {
-        if (_disposed == false)
+        if (!_disposed)
         {
             _disposed = true;
             _watcherCancelSource.Cancel(); // request the cancellation
@@ -206,4 +314,19 @@ public void Dispose()
             _inputBuffer.Dispose();
         }
     }
-}
+
+    /// <summary>
+    /// Asynchronously releases the unmanaged resources used by the ConcurrentStream.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous dispose operation.</returns>
+    public async ValueTask DisposeAsync()
+    {
+        if (!_disposed)
+        {
+            _disposed = true;
+            await _watcherCancelSource.CancelAsync().ConfigureAwait(false); // request the cancellation
+            await _stream.DisposeAsync().ConfigureAwait(false);
+            _inputBuffer.Dispose();
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Downloader/Download.cs b/src/Downloader/Download.cs
index e9a1f1e..4afbc69 100644
--- a/src/Downloader/Download.cs
+++ b/src/Downloader/Download.cs
@@ -20,26 +20,26 @@ internal class Download : IDownload
 
     public event EventHandler<DownloadProgressChangedEventArgs> ChunkDownloadProgressChanged
     {
-        add { _downloadService.ChunkDownloadProgressChanged += value; }
-        remove { _downloadService.ChunkDownloadProgressChanged -= value; }
+        add => _downloadService.ChunkDownloadProgressChanged += value;
+        remove => _downloadService.ChunkDownloadProgressChanged -= value;
     }
 
     public event EventHandler<AsyncCompletedEventArgs> DownloadFileCompleted
     {
-        add { _downloadService.DownloadFileCompleted += value; }
-        remove { _downloadService.DownloadFileCompleted -= value; }
+        add => _downloadService.DownloadFileCompleted += value;
+        remove => _downloadService.DownloadFileCompleted -= value;
     }
 
     public event EventHandler<DownloadProgressChangedEventArgs> DownloadProgressChanged
     {
-        add { _downloadService.DownloadProgressChanged += value; }
-        remove { _downloadService.DownloadProgressChanged -= value; }
+        add => _downloadService.DownloadProgressChanged += value;
+        remove => _downloadService.DownloadProgressChanged -= value;
     }
 
     public event EventHandler<DownloadStartedEventArgs> DownloadStarted
     {
-        add { _downloadService.DownloadStarted += value; }
-        remove { _downloadService.DownloadStarted -= value; }
+        add => _downloadService.DownloadStarted += value;
+        remove => _downloadService.DownloadStarted -= value;
     }
 
     public Download(string url, string path, string filename, DownloadConfiguration configuration)
@@ -72,26 +72,26 @@ public async Task<Stream> StartAsync(CancellationToken cancellationToken = defau
             {
                 return await _downloadService.DownloadFileTaskAsync(Url, cancellationToken).ConfigureAwait(false);
             }
-            else if (string.IsNullOrWhiteSpace(Filename))
-            {
-                await _downloadService.DownloadFileTaskAsync(Url, new DirectoryInfo(Folder), cancellationToken).ConfigureAwait(false);
-                return null;
-            }
-            else
+
+            if (string.IsNullOrWhiteSpace(Filename))
             {
-                // with Folder and Filename
-                await _downloadService.DownloadFileTaskAsync(Url, Path.Combine(Folder, Filename), cancellationToken).ConfigureAwait(false);
+                await _downloadService.DownloadFileTaskAsync(Url, new DirectoryInfo(Folder!), cancellationToken)
+                    .ConfigureAwait(false);
                 return null;
             }
+
+            // with Folder and Filename
+            await _downloadService.DownloadFileTaskAsync(Url, Path.Combine(Folder!, Filename), cancellationToken)
+                .ConfigureAwait(false);
+            return null;
         }
-        else if(string.IsNullOrWhiteSpace(Url))
+
+        if (string.IsNullOrWhiteSpace(Url))
         {
             return await _downloadService.DownloadFileTaskAsync(Package, cancellationToken).ConfigureAwait(false);
         }
-        else
-        {
-            return await _downloadService.DownloadFileTaskAsync(Package, Url, cancellationToken).ConfigureAwait(false);
-        }
+
+        return await _downloadService.DownloadFileTaskAsync(Package, Url, cancellationToken).ConfigureAwait(false);
     }
 
     public void Stop()
@@ -123,9 +123,15 @@ public override int GetHashCode()
         return hashCode;
     }
 
-    public async void Dispose()
+    public async ValueTask DisposeAsync()
     {
         await _downloadService.Clear().ConfigureAwait(false);
         Package = null;
     }
-}
+
+    public void Dispose()
+    {
+        _downloadService.Clear().Wait();
+        Package = null;
+    }
+}
\ No newline at end of file
diff --git a/src/Downloader/DownloadPackage.cs b/src/Downloader/DownloadPackage.cs
index 415891d..0041c5d 100644
--- a/src/Downloader/DownloadPackage.cs
+++ b/src/Downloader/DownloadPackage.cs
@@ -5,21 +5,74 @@
 
 namespace Downloader;
 
-public class DownloadPackage : IDisposable
+/// <summary>
+/// Represents a package containing information about a download operation.
+/// </summary>
+public class DownloadPackage : IDisposable, IAsyncDisposable
 {
+    /// <summary>
+    /// Gets or sets a value indicating whether the package is currently being saved.
+    /// </summary>
     public bool IsSaving { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether the save operation is complete.
+    /// </summary>
     public bool IsSaveComplete { get; set; }
+
+    /// <summary>
+    /// Gets or sets the progress of the save operation.
+    /// </summary>
     public double SaveProgress { get; set; }
+
+    /// <summary>
+    /// Gets or sets the status of the download operation.
+    /// </summary>
     public DownloadStatus Status { get; set; } = DownloadStatus.None;
+
+    /// <summary>
+    /// Gets or sets the URLs from which the file is being downloaded.
+    /// </summary>
     public string[] Urls { get; set; }
+
+    /// <summary>
+    /// Gets or sets the total size of the file to be downloaded.
+    /// </summary>
     public long TotalFileSize { get; set; }
+
+    /// <summary>
+    /// Gets or sets the name of the file to be saved.
+    /// </summary>
     public string FileName { get; set; }
+
+    /// <summary>
+    /// Gets or sets the chunks of the file being downloaded.
+    /// </summary>
     public Chunk[] Chunks { get; set; }
+
+    /// <summary>
+    /// Gets the total size of the received bytes.
+    /// </summary>
     public long ReceivedBytesSize => Chunks?.Sum(chunk => chunk.Position) ?? 0;
+
+    /// <summary>
+    /// Gets or sets a value indicating whether the download supports range requests.
+    /// </summary>
     public bool IsSupportDownloadInRange { get; set; } = true;
+
+    /// <summary>
+    /// Gets a value indicating whether the download is being stored in memory.
+    /// </summary>
     public bool InMemoryStream => string.IsNullOrWhiteSpace(FileName);
+
+    /// <summary>
+    /// Gets or sets the storage for the download.
+    /// </summary>
     public ConcurrentStream Storage { get; set; }
 
+    /// <summary>
+    /// Clears the chunks and resets the package.
+    /// </summary>
     public void Clear()
     {
         if (Chunks != null)
@@ -27,15 +80,23 @@ public void Clear()
             foreach (Chunk chunk in Chunks)
                 chunk.Clear();
         }
+
         Chunks = null;
     }
 
+    /// <summary>
+    /// Flushes the storage asynchronously.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous flush operation.</returns>
     public async Task FlushAsync()
     {
         if (Storage?.CanWrite == true)
             await Storage.FlushAsync().ConfigureAwait(false);
     }
 
+    /// <summary>
+    /// Flushes the storage synchronously.
+    /// </summary>
     [Obsolete("This method has been deprecated. Please use FlushAsync instead.")]
     public void Flush()
     {
@@ -43,6 +104,9 @@ public void Flush()
             Storage?.FlushAsync().Wait();
     }
 
+    /// <summary>
+    /// Validates the chunks and ensures they are in the correct position.
+    /// </summary>
     public void Validate()
     {
         foreach (var chunk in Chunks)
@@ -61,17 +125,37 @@ public void Validate()
         }
     }
 
+    /// <summary>
+    /// Builds the storage for the download package.
+    /// </summary>
+    /// <param name="reserveFileSize">Indicates whether to reserve the file size.</param>
+    /// <param name="maxMemoryBufferBytes">The maximum size of the memory buffer in bytes.</param>
+    /// <param name="logger">The logger to use for logging.</param>
     public void BuildStorage(bool reserveFileSize, long maxMemoryBufferBytes = 0, ILogger logger = null)
     {
-        if (string.IsNullOrWhiteSpace(FileName))
-            Storage = new ConcurrentStream(maxMemoryBufferBytes, logger);
-        else
-            Storage = new ConcurrentStream(FileName, reserveFileSize ? TotalFileSize : 0, maxMemoryBufferBytes, logger);
+        Storage = string.IsNullOrWhiteSpace(FileName)
+            ? new ConcurrentStream(maxMemoryBufferBytes, logger)
+            : new ConcurrentStream(FileName, reserveFileSize ? TotalFileSize : 0, maxMemoryBufferBytes, logger);
     }
 
+    /// <summary>
+    /// Disposes of the download package, clearing the chunks and disposing of the storage.
+    /// </summary>
     public void Dispose()
     {
         Clear();
         Storage?.Dispose();
     }
+
+    /// <summary>
+    /// Disposes of the download package, clearing the chunks and disposing of the storage.
+    /// </summary>
+    public async ValueTask DisposeAsync()
+    {
+        Clear();
+        if (Storage is not null)
+        {
+            await Storage.DisposeAsync().ConfigureAwait(false);
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/Downloader/IDownload.cs b/src/Downloader/IDownload.cs
index 742d60f..3306547 100644
--- a/src/Downloader/IDownload.cs
+++ b/src/Downloader/IDownload.cs
@@ -1,28 +1,90 @@
-using System.ComponentModel;
-using System;
-using System.Threading.Tasks;
+using System;
+using System.ComponentModel;
 using System.IO;
 using System.Threading;
+using System.Threading.Tasks;
 
 namespace Downloader;
 
-public interface IDownload : IDisposable
+/// <summary>
+/// Represents an interface for managing file downloads.
+/// </summary>
+public interface IDownload : IDisposable, IAsyncDisposable
 {
+    /// <summary>
+    /// Gets the URL of the file to be downloaded.
+    /// </summary>
     public string Url { get; }
+
+    /// <summary>
+    /// Gets the folder where the downloaded file will be saved.
+    /// </summary>
     public string Folder { get; }
+
+    /// <summary>
+    /// Gets the name of the file to be saved.
+    /// </summary>
     public string Filename { get; }
+
+    /// <summary>
+    /// Gets the size of the downloaded portion of the file.
+    /// </summary>
     public long DownloadedFileSize { get; }
+
+    /// <summary>
+    /// Gets the total size of the file to be downloaded.
+    /// </summary>
     public long TotalFileSize { get; }
+
+    /// <summary>
+    /// Gets the download package containing information about the download.
+    /// </summary>
     public DownloadPackage Package { get; }
+
+    /// <summary>
+    /// Gets the current status of the download.
+    /// </summary>
     public DownloadStatus Status { get; }
 
+    /// <summary>
+    /// Occurs when the progress of a chunk download changes.
+    /// </summary>
     public event EventHandler<DownloadProgressChangedEventArgs> ChunkDownloadProgressChanged;
+
+    /// <summary>
+    /// Occurs when the download file operation is completed.
+    /// </summary>
     public event EventHandler<AsyncCompletedEventArgs> DownloadFileCompleted;
+
+    /// <summary>
+    /// Occurs when the overall download progress changes.
+    /// </summary>
     public event EventHandler<DownloadProgressChangedEventArgs> DownloadProgressChanged;
+
+    /// <summary>
+    /// Occurs when the download operation starts.
+    /// </summary>
     public event EventHandler<DownloadStartedEventArgs> DownloadStarted;
 
+    /// <summary>
+    /// Starts the download operation asynchronously.
+    /// </summary>
+    /// <param name="cancellationToken">A cancellation token that can be used to cancel the download.</param>
+    /// <returns>A task that represents the asynchronous download operation. The task result contains the downloaded stream.</returns>
     public Task<Stream> StartAsync(CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Stops the download operation.
+    /// </summary>
     public void Stop();
+
+    /// <summary>
+    /// Pauses the download operation.
+    /// </summary>
     public void Pause();
+
+    /// <summary>
+    /// Resumes the paused download operation.
+    /// </summary>
     public void Resume();
-}
+}
\ No newline at end of file