Add File extensions: WriteAllZeroes, ReadAllBytes(offset), ReadAllBytes(offset, length), ReadAllBytesAsync(offset), ReadAllBytesAsync(offset, length)

PowerKit.Tests/FileExtensionsTests.cs

@@ -0,0 +1,120 @@
+using System.IO;
+using System.Threading.Tasks;
+using FluentAssertions;
+using PowerKit.Extensions;
+using Xunit;
+
+namespace PowerKit.Tests;
+
+public class FileExtensionsTests
+{
+    [Fact]
+    public void WriteAllZeroes_Test()
+    {
+        // Arrange
+        var path = Path.GetTempFileName();
+
+        try
+        {
+            // Act
+            File.WriteAllZeroes(path, 1024);
+
+            // Assert
+            var bytes = File.ReadAllBytes(path);
+            bytes.Should().HaveCount(1024);
+            bytes.Should().AllSatisfy(b => b.Should().Be(0));
+        }
+        finally
+        {
+            File.Delete(path);
+        }
+    }
+
+    [Fact]
+    public void ReadAllBytes_WithOffset_Test()
+    {
+        // Arrange
+        var path = Path.GetTempFileName();
+
+        try
+        {
+            File.WriteAllBytes(path, [1, 2, 3, 4, 5]);
+
+            // Act
+            var bytes = File.ReadAllBytes(path, offset: 2L);
+
+            // Assert
+            bytes.Should().Equal(3, 4, 5);
+        }
+        finally
+        {
+            File.Delete(path);
+        }
+    }
+
+    [Fact]
+    public void ReadAllBytes_WithOffsetAndLength_Test()
+    {
+        // Arrange
+        var path = Path.GetTempFileName();
+
+        try
+        {
+            File.WriteAllBytes(path, [1, 2, 3, 4, 5]);
+
+            // Act
+            var bytes = File.ReadAllBytes(path, offset: 1L, length: 3L);
+
+            // Assert
+            bytes.Should().Equal(2, 3, 4);
+        }
+        finally
+        {
+            File.Delete(path);
+        }
+    }
+
+    [Fact]
+    public async Task ReadAllBytesAsync_WithOffset_Test()
+    {
+        // Arrange
+        var path = Path.GetTempFileName();
+
+        try
+        {
+            File.WriteAllBytes(path, [1, 2, 3, 4, 5]);
+
+            // Act
+            var bytes = await File.ReadAllBytesAsync(path, offset: 2L);
+
+            // Assert
+            bytes.Should().Equal(3, 4, 5);
+        }
+        finally
+        {
+            File.Delete(path);
+        }
+    }
+
+    [Fact]
+    public async Task ReadAllBytesAsync_WithOffsetAndLength_Test()
+    {
+        // Arrange
+        var path = Path.GetTempFileName();
+
+        try
+        {
+            File.WriteAllBytes(path, [1, 2, 3, 4, 5]);
+
+            // Act
+            var bytes = await File.ReadAllBytesAsync(path, offset: 1L, length: 3L);
+
+            // Assert
+            bytes.Should().Equal(2, 3, 4);
+        }
+        finally
+        {
+            File.Delete(path);
+        }
+    }
+}

PowerKit/Extensions/FileExtensions.cs

@@ -0,0 +1,119 @@
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace PowerKit.Extensions;
+
+internal static class FileExtensions
+{
+    extension(File)
+    {
+        /// <summary>
+        /// Creates a file at the specified path and fills it with zeroes.
+        /// </summary>
+        public static void WriteAllZeroes(string path, long count)
+        {
+            using var stream = new FileStream(
+                path,
+                FileMode.Create,
+                FileAccess.Write,
+                FileShare.None
+            );
+
+            stream.SetLength(count);
+        }
+
+        /// <summary>
+        /// Reads all bytes from the specified file starting at the given offset.
+        /// </summary>
+        public static byte[] ReadAllBytes(string path, long offset)
+        {
+            using var stream = new FileStream(
+                path,
+                FileMode.Open,
+                FileAccess.Read,
+                FileShare.ReadWrite
+            );
+
+            stream.Seek(offset, SeekOrigin.Begin);
+
+            var buffer = new byte[checked((int)(stream.Length - offset))];
+            stream.ReadExactly(buffer);
+
+            return buffer;
+        }
+
+        /// <summary>
+        /// Reads the specified number of bytes from the file starting at the given offset.
+        /// </summary>
+        public static byte[] ReadAllBytes(string path, long offset, long length)
+        {
+            using var stream = new FileStream(
+                path,
+                FileMode.Open,
+                FileAccess.Read,
+                FileShare.ReadWrite
+            );
+
+            stream.Seek(offset, SeekOrigin.Begin);
+
+            var buffer = new byte[checked((int)length)];
+            stream.ReadExactly(buffer);
+
+            return buffer;
+        }
+
+        /// <summary>
+        /// Reads all bytes from the specified file starting at the given offset asynchronously.
+        /// </summary>
+        public static async Task<byte[]> ReadAllBytesAsync(
+            string path,
+            long offset,
+            CancellationToken cancellationToken = default
+        )
+        {
+            using var stream = new FileStream(
+                path,
+                FileMode.Open,
+                FileAccess.Read,
+                FileShare.ReadWrite,
+                bufferSize: 4096,
+                FileOptions.Asynchronous
+            );
+
+            stream.Seek(offset, SeekOrigin.Begin);
+
+            var buffer = new byte[checked((int)(stream.Length - offset))];
+            await stream.ReadExactlyAsync(buffer, cancellationToken).ConfigureAwait(false);
+
+            return buffer;
+        }
+
+        /// <summary>
+        /// Reads the specified number of bytes from the file starting at the given offset asynchronously.
+        /// </summary>
+        public static async Task<byte[]> ReadAllBytesAsync(
+            string path,
+            long offset,
+            long length,
+            CancellationToken cancellationToken = default
+        )
+        {
+            using var stream = new FileStream(
+                path,
+                FileMode.Open,
+                FileAccess.Read,
+                FileShare.ReadWrite,
+                bufferSize: 4096,
+                FileOptions.Asynchronous
+            );
+
+            stream.Seek(offset, SeekOrigin.Begin);
+
+            var buffer = new byte[checked((int)length)];
+            await stream.ReadExactlyAsync(buffer, cancellationToken).ConfigureAwait(false);
+
+            return buffer;
+        }
+    }
+}