local file

Directory.Build.props

@@ -14,8 +14,8 @@
         <PackageLicenseExpression>MIT</PackageLicenseExpression>
         <PackageReadmeFile>README.md</PackageReadmeFile>
         <Product>Managed Code - Storage</Product>
-        <Version>2.1.7</Version>
-        <PackageVersion>2.1.7</PackageVersion>
+        <Version>2.1.8</Version>
+        <PackageVersion>2.1.8</PackageVersion>
     </PropertyGroup>
     <PropertyGroup Condition="'$(GITHUB_ACTIONS)' == 'true'">
         <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>

ManagedCode.Storage.Core/Models/LocalFile.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Threading.Tasks;
 
@@ -115,6 +116,62 @@ public void Dispose()
         }
     }
 
+    ~LocalFile()
+    {
+        Dispose();
+    }
+
+    private void CloseFileStream()
+    {
+        _stream?.Dispose();
+        _stream = null;
+    }
+
+    public void Close()
+    {
+        lock (_lockObject)
+        {
+            CloseFileStream();
+        }
+    }
+
+    public async Task<LocalFile> CopyFromStreamAsync(Stream stream)
+    {
+        await stream.CopyToAsync(FileStream);
+        FileStream.Dispose();
+        return this;
+    }
+
+    public static async Task<LocalFile> FromStreamAsync(Stream stream)
+    {
+        var file = new LocalFile();
+        await stream.CopyToAsync(file.FileStream);
+        file.FileStream.Dispose();
+
+        return file;
+    }
+
+    public static async Task<LocalFile> FromStreamAsync(Stream stream, string fileName)
+    {
+        var file = FromFileName(fileName);
+        await stream.CopyToAsync(file.FileStream);
+        await file.FileStream.DisposeAsync();
+
+        return file;
+    }
+
+    public static LocalFile FromFileName(string fileName)
+    {
+        return new LocalFile(Path.Combine(Path.GetTempPath(), fileName));
+    }
+
+    public static LocalFile FromTempFile()
+    {
+        return new LocalFile();
+    }
+
+    #region Read
+
     public string ReadAllText()
     {
         lock (_lockObject)
@@ -151,57 +208,90 @@ public Task<string[]> ReadAllLinesAsync()
         }
     }
 
-    ~LocalFile()
+    public byte[] ReadAllBytes()
     {
-        Dispose();
+        lock (_lockObject)
+        {
+            CloseFileStream();
+            return File.ReadAllBytes(FilePath);
+        }
     }
 
-    private void CloseFileStream()
+    public Task<byte[]> ReadAllBytesAsync()
     {
-        _stream?.Dispose();
-        _stream = null;
+        lock (_lockObject)
+        {
+            CloseFileStream();
+            return File.ReadAllBytesAsync(FilePath);
+        }
     }
 
-    public void Close()
+    public IEnumerable<string> ReadLines()
     {
         lock (_lockObject)
         {
             CloseFileStream();
+            return File.ReadLines(FilePath);
         }
     }
 
-    public async Task<LocalFile> CopyFromStreamAsync(Stream stream)
+    #endregion
+
+    #region Write
+
+    public void WriteAllText(string content)
     {
-        await stream.CopyToAsync(FileStream);
-        FileStream.Dispose();
-        return this;
+        lock (_lockObject)
+        {
+            CloseFileStream();
+            File.WriteAllText(FilePath, content);
+        }
     }
 
-    public static async Task<LocalFile> FromStreamAsync(Stream stream)
+    public Task WriteAllTextAsync(string content)
     {
-        var file = new LocalFile();
-        await stream.CopyToAsync(file.FileStream);
-        file.FileStream.Dispose();
-
-        return file;
+        lock (_lockObject)
+        {
+            CloseFileStream();
+            return File.WriteAllTextAsync(FilePath, content);
+        }
     }
 
-    public static async Task<LocalFile> FromStreamAsync(Stream stream, string fileName)
+    public void WriteAllLines(IEnumerable<string> contents)
     {
-        var file = FromFileName(fileName);
-        await stream.CopyToAsync(file.FileStream);
-        await file.FileStream.DisposeAsync();
+        lock (_lockObject)
+        {
+            CloseFileStream();
+            File.WriteAllLines(FilePath, contents);
+        }
+    }
 
-        return file;
+    public Task WriteAllLinesAsync(IEnumerable<string> contents)
+    {
+        lock (_lockObject)
+        {
+            CloseFileStream();
+            return File.WriteAllLinesAsync(FilePath, contents);
+        }
     }
 
-    public static LocalFile FromFileName(string fileName)
+    public void WriteAllBytes(byte[] bytes)
     {
-        return new LocalFile(Path.Combine(Path.GetTempPath(), fileName));
+        lock (_lockObject)
+        {
+            CloseFileStream();
+            File.WriteAllBytes(FilePath, bytes);
+        }
     }
 
-    public static LocalFile FromTempFile()
+    public Task WriteAllBytesAsync(byte[] bytes)
     {
-        return new LocalFile();
+        lock (_lockObject)
+        {
+            CloseFileStream();
+            return File.WriteAllBytesAsync(FilePath, bytes);
+        }
     }
+
+    #endregion
 }