implemented azure blob operations except list fetching

dudchenko610 · dudchenko610 · commit 319aaf227408 · 2022-01-19T17:27:20.000+02:00
diff --git a/ManagedCode.Storage.Azure/AzureBlobStorage.cs b/ManagedCode.Storage.Azure/AzureBlobStorage.cs
@@ -1,101 +1,146 @@
-﻿using ManagedCode.Storage.Core;
+﻿using Azure.Storage.Blobs;
+using Azure.Storage.Blobs.Models;
+using ManagedCode.Storage.Azure.Options;
+using ManagedCode.Storage.Core;
 using ManagedCode.Storage.Core.Models;
-using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 
 namespace ManagedCode.Storage.Azure
 {
     public class AzureBlobStorage : IBlobStorage
     {
+        private readonly BlobContainerClient _blobContainerClient;
+
         public AzureBlobStorage(AzureBlobStorageConnectionOptions connectionOptions)
         {
-        //    var blobServiceClient = new BlobServiceClient(connectionOptions.ConnectionString);
-        }
+            _blobContainerClient = new BlobContainerClient(
+                connectionOptions.ConnectionString,
+                connectionOptions.Container
+            );
 
-        public Task DeleteAsync(string blob, CancellationToken cancellationToken = default)
-        {
-            throw new System.NotImplementedException();
+            _blobContainerClient.CreateIfNotExists(PublicAccessType.BlobContainer);
         }
 
-        public Task DeleteAsync(Blob blob, CancellationToken cancellationToken = default)
+        public void Dispose()
         {
-            throw new System.NotImplementedException();
         }
 
-        public Task DeleteAsync(IEnumerable<string> blobs, CancellationToken cancellationToken = default)
-        {
-            throw new System.NotImplementedException();
-        }
+        #region Delete
 
-        public Task DeleteAsync(IEnumerable<Blob> blobs, CancellationToken cancellationToken = default)
+        public async Task DeleteAsync(string blob, CancellationToken cancellationToken = default)
         {
-            throw new System.NotImplementedException();
+            var blobClient = _blobContainerClient.GetBlobClient(blob);
+            await blobClient.DeleteAsync(DeleteSnapshotsOption.None, null, cancellationToken);
         }
 
-        public void Dispose()
+        public async Task DeleteAsync(Blob blob, CancellationToken cancellationToken = default)
         {
-            throw new System.NotImplementedException();
+            var blobClient = _blobContainerClient.GetBlobClient(blob.Name);
+            await blobClient.DeleteAsync(DeleteSnapshotsOption.None, null, cancellationToken);
         }
 
-        public Task<Stream> DownloadAsStreamAsync(string blob, CancellationToken cancellationToken = default)
+        public async Task DeleteAsync(IEnumerable<string> blobs, CancellationToken cancellationToken = default)
         {
-            throw new System.NotImplementedException();
+            foreach (var blobName in blobs)
+            {
+                await DeleteAsync(blobName, cancellationToken);
+            }
         }
 
-        public Task<Stream> DownloadAsStreamAsync(Blob blob, CancellationToken cancellationToken = default)
+        public async Task DeleteAsync(IEnumerable<Blob> blobs, CancellationToken cancellationToken = default)
         {
-            throw new System.NotImplementedException();
+            foreach (var blob in blobs)
+            {
+                await DeleteAsync(blob, cancellationToken);
+            }
         }
 
-        public Task<LocalFile> DownloadAsync(string blob, CancellationToken cancellationToken = default)
+        #endregion
+
+        public async Task<Stream> DownloadAsStreamAsync(string blob, CancellationToken cancellationToken = default)
         {
-            throw new System.NotImplementedException();
+            var blobClient = _blobContainerClient.GetBlobClient(blob);
+            var res = await blobClient.DownloadStreamingAsync();
+
+            return res.Value.Content;
         }
 
-        public Task<LocalFile> DownloadAsync(Blob blob, CancellationToken cancellationToken = default)
+        public async Task<Stream> DownloadAsStreamAsync(Blob blob, CancellationToken cancellationToken = default)
         {
-            throw new System.NotImplementedException();
+            return await DownloadAsStreamAsync(blob.Name, cancellationToken);
         }
 
-        public Task<bool> ExistsAsync(string blob, CancellationToken cancellationToken = default)
+        public async Task<LocalFile> DownloadAsync(string blob, CancellationToken cancellationToken = default)
         {
-            throw new System.NotImplementedException();
+            var blobClient = _blobContainerClient.GetBlobClient(blob);
+            var localFile = new LocalFile();
+
+            await blobClient.DownloadToAsync(localFile.FileStream, cancellationToken);
+
+            return localFile;
         }
 
-        public Task<bool> ExistsAsync(Blob blob, CancellationToken cancellationToken = default)
+        public async Task<LocalFile> DownloadAsync(Blob blob, CancellationToken cancellationToken = default)
         {
-            throw new System.NotImplementedException();
+            return await DownloadAsync(blob.Name, cancellationToken);
         }
 
-        public IAsyncEnumerable<bool> ExistsAsync(IEnumerable<string> blobs, CancellationToken cancellationToken = default)
+        #region Exists
+
+        public async Task<bool> ExistsAsync(string blob, CancellationToken cancellationToken = default)
         {
-            throw new System.NotImplementedException();
+            var blobClient = _blobContainerClient.GetBlobClient(blob);
+
+            return await blobClient.ExistsAsync(cancellationToken);
         }
 
-        public IAsyncEnumerable<bool> ExistsAsync(IEnumerable<Blob> blobs, CancellationToken cancellationToken = default)
+        public async Task<bool> ExistsAsync(Blob blob, CancellationToken cancellationToken = default)
         {
-            throw new System.NotImplementedException();
+            var blobClient = _blobContainerClient.GetBlobClient(blob.Name);
+
+            return await blobClient.ExistsAsync(cancellationToken);
         }
 
-        public IAsyncEnumerable<Blob> GetBlob(string blob, CancellationToken cancellationToken = default)
+        public async IAsyncEnumerable<bool> ExistsAsync(IEnumerable<string> blobs, 
+            [EnumeratorCancellation] CancellationToken cancellationToken = default)
         {
-            throw new System.NotImplementedException();
+            foreach(var blob in blobs)
+            {
+                var blobClient = _blobContainerClient.GetBlobClient(blob);
+                yield return await blobClient.ExistsAsync(cancellationToken);
+            }
         }
 
-        public IAsyncEnumerable<Blob> GetBlob(Blob blob, CancellationToken cancellationToken = default)
+        public async IAsyncEnumerable<bool> ExistsAsync(IEnumerable<Blob> blobs,
+             [EnumeratorCancellation] CancellationToken cancellationToken = default)
         {
-            throw new System.NotImplementedException();
+            foreach (var blob in blobs)
+            {
+                var blobClient = _blobContainerClient.GetBlobClient(blob.Name);
+                yield return await blobClient.ExistsAsync(cancellationToken);
+            }
         }
 
-        public IAsyncEnumerable<Blob> GetBlob(IEnumerable<string> blobs, CancellationToken cancellationToken = default)
+        #endregion
+
+        public async Task<Blob> GetBlobAsync(string blob, CancellationToken cancellationToken = default)
         {
-            throw new System.NotImplementedException();
+            await Task.Yield();
+
+            var blobClient = _blobContainerClient.GetBlobClient(blob);
+           
+            return new Blob()
+            {
+                Name = blobClient.Name,
+                Uri = blobClient.Uri
+            };
         }
 
-        public IAsyncEnumerable<Blob> GetBlob(IEnumerable<Blob> blobs, CancellationToken cancellationToken = default)
+        public IAsyncEnumerable<Blob> GetBlobsAsync(IEnumerable<string> blobs, CancellationToken cancellationToken = default)
         {
             throw new System.NotImplementedException();
         }
@@ -105,24 +150,34 @@ public IAsyncEnumerable<Blob> GetBlobListAsync(CancellationToken cancellationTok
             throw new System.NotImplementedException();
         }
 
-        public Task UploadAsync(string blob, Stream dataStream, bool append = false, CancellationToken cancellationToken = default)
+        #region Upload
+
+        public async Task UploadAsync(string blob, Stream dataStream, bool append = false, CancellationToken cancellationToken = default)
         {
-            throw new System.NotImplementedException();
+            var blobClient = _blobContainerClient.GetBlobClient(blob);
+            await blobClient.UploadAsync(dataStream, cancellationToken);
         }
 
-        public Task UploadAsync(string blob, string pathToFile, bool append = false, CancellationToken cancellationToken = default)
+        public async Task UploadAsync(string blob, string pathToFile, bool append = false, CancellationToken cancellationToken = default)
         {
-            throw new System.NotImplementedException();
+            var blobClient = _blobContainerClient.GetBlobClient(blob);
+
+            using (var fs = new FileStream(pathToFile, FileMode.Open, FileAccess.Read))
+            {
+                await blobClient.UploadAsync(fs, cancellationToken);
+            }
         }
 
-        public Task UploadAsync(Blob blob, Stream dataStream, bool append = false, CancellationToken cancellationToken = default)
+        public async Task UploadAsync(Blob blob, Stream dataStream, bool append = false, CancellationToken cancellationToken = default)
         {
-            throw new System.NotImplementedException();
+            await UploadAsync(blob.Name, dataStream, append, cancellationToken);
         }
 
-        public Task UploadAsync(Blob blob, string pathToFile, bool append = false, CancellationToken cancellationToken = default)
+        public async Task UploadAsync(Blob blob, string pathToFile, bool append = false, CancellationToken cancellationToken = default)
         {
-            throw new System.NotImplementedException();
+            await UploadAsync(blob.Name, pathToFile, append, cancellationToken);
         }
+
+        #endregion
     }
 }
diff --git a/ManagedCode.Storage.Azure/EnumeratorCacellationAttribute.cs b/ManagedCode.Storage.Azure/EnumeratorCacellationAttribute.cs
@@ -0,0 +1,8 @@
+﻿using System;
+
+namespace ManagedCode.Storage.Azure
+{
+    internal class EnumeratorCacellationAttribute : Attribute
+    {
+    }
+}
diff --git a/ManagedCode.Storage.Azure/Extensions/ProviderExtensions.cs b/ManagedCode.Storage.Azure/Extensions/ProviderExtensions.cs
@@ -3,6 +3,7 @@
 using ManagedCode.Storage.Core.Builders;
 using ManagedCode.Storage.Core.Helpers;
 using ManagedCode.Storage.Core;
+using ManagedCode.Storage.Azure.Options;
 
 namespace ManagedCode.Storage.Azure.Extensions
 {
diff --git a/ManagedCode.Storage.Azure/Options/AzureBlobStorageConnectionOptions.cs b/ManagedCode.Storage.Azure/Options/AzureBlobStorageConnectionOptions.cs
@@ -1,4 +1,4 @@
-﻿namespace ManagedCode.Storage.Azure
+﻿namespace ManagedCode.Storage.Azure.Options
 {
     public class AzureBlobStorageConnectionOptions
     {
diff --git a/ManagedCode.Storage.Core/IBlobStorage.cs b/ManagedCode.Storage.Core/IBlobStorage.cs
@@ -10,11 +10,9 @@ namespace ManagedCode.Storage.Core
     public interface IBlobStorage : IDisposable
     {
         IAsyncEnumerable<Blob> GetBlobListAsync(CancellationToken cancellationToken = default);
-        IAsyncEnumerable<Blob> GetBlob(string blob, CancellationToken cancellationToken = default);
-        IAsyncEnumerable<Blob> GetBlob(Blob blob, CancellationToken cancellationToken = default);
-        IAsyncEnumerable<Blob> GetBlob(IEnumerable<string> blobs, CancellationToken cancellationToken = default);
-        IAsyncEnumerable<Blob> GetBlob(IEnumerable<Blob> blobs, CancellationToken cancellationToken = default);
-        
+        IAsyncEnumerable<Blob> GetBlobsAsync(IEnumerable<string> blobs, CancellationToken cancellationToken = default);
+        Task<Blob> GetBlobAsync(string blob, CancellationToken cancellationToken = default);
+
         Task UploadAsync(string blob, Stream dataStream, bool append = false, CancellationToken cancellationToken = default);
         Task UploadAsync(string blob, string pathToFile, bool append = false, CancellationToken cancellationToken = default);
         Task UploadAsync(Blob blob, Stream dataStream, bool append = false, CancellationToken cancellationToken = default);
diff --git a/ManagedCode.Storage.Core/Models/Blob.cs b/ManagedCode.Storage.Core/Models/Blob.cs
@@ -1,7 +1,10 @@
-﻿namespace ManagedCode.Storage.Core.Models
+﻿using System;
+
+namespace ManagedCode.Storage.Core.Models
 {
     public class Blob
     {
-        public string Path { get; set; }
+        public string Name { get; set; }
+        public Uri Uri { get; set; }
     }
 }
diff --git a/ManagedCode.Storage.Tests/Azure/DependencyInjectionTests.cs b/ManagedCode.Storage.Tests/Azure/DependencyInjectionTests.cs
@@ -13,32 +13,38 @@ public class DependencyInjectionTests
         private IDocumentStorage _documentStorage;
 
         public DependencyInjectionTests()
-        {
-           
-        }
-
-        [Fact]
-        public void WhenDIInitialized()
         {
             var services = new ServiceCollection();
 
             services.AddManagedCodeStorage()
                 .AddAzureBlobStorage<IPhotoStorage>(opt => {
-                    opt.ConnectionString = "";
+                    opt.ConnectionString = "DefaultEndpointsProtocol=https;AccountName=storagestudying;AccountKey=4Y4IBrITEoWYMGe0gNju9wvUQrWi//1VvPIDN2dYWccWKy9uuKWnMBXxQlmcy3Q9UIU70ZJiy8ULD9QITxyeTQ==;EndpointSuffix=core.windows.net";
                     opt.Container = "photos";
                 })
                 .AddAzureBlobStorage<IDocumentStorage>(opt => {
-                    opt.ConnectionString = "";
+                    opt.ConnectionString = "DefaultEndpointsProtocol=https;AccountName=storagestudying;AccountKey=4Y4IBrITEoWYMGe0gNju9wvUQrWi//1VvPIDN2dYWccWKy9uuKWnMBXxQlmcy3Q9UIU70ZJiy8ULD9QITxyeTQ==;EndpointSuffix=core.windows.net";
                     opt.Container = "documents";
                 });
 
             var provider = services.BuildServiceProvider();
 
             _photoStorage = provider.GetService<IPhotoStorage>();
             _documentStorage = provider.GetService<IDocumentStorage>();
+        }
 
+        [Fact]
+        public void WhenDIInitialized()
+        {
             _photoStorage.Should().NotBeNull();
             _documentStorage.Should().NotBeNull();
         }
+
+        [Fact]
+        public async Task WhenSingleBlobExistsIsCalled()
+        {
+            var result = await _photoStorage.ExistsAsync("34.png");
+
+            result.Should().BeTrue();
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -1,101 +1,146 @@`
`1`		`-using ManagedCode.Storage.Core;`
	`1`	`+using Azure.Storage.Blobs;`
	`2`	`+using Azure.Storage.Blobs.Models;`
	`3`	`+using ManagedCode.Storage.Azure.Options;`
	`4`	`+using ManagedCode.Storage.Core;`
`2`	`5`	`using ManagedCode.Storage.Core.Models;`
`3`		`-using System;`
`4`	`6`	`using System.Collections.Generic;`
`5`	`7`	`using System.IO;`
	`8`	`+using System.Runtime.CompilerServices;`
`6`	`9`	`using System.Threading;`
`7`	`10`	`using System.Threading.Tasks;`
`8`	`11`
`9`	`12`	`namespace ManagedCode.Storage.Azure`
`10`	`13`	`{`
`11`	`14`	`public class AzureBlobStorage : IBlobStorage`
`12`	`15`	`{`
	`16`	`+ private readonly BlobContainerClient _blobContainerClient;`
	`17`	`+`
`13`	`18`	`public AzureBlobStorage(AzureBlobStorageConnectionOptions connectionOptions)`
`14`	`19`	`{`
`15`		`- // var blobServiceClient = new BlobServiceClient(connectionOptions.ConnectionString);`
`16`		`- }`
	`20`	`+ _blobContainerClient = new BlobContainerClient(`
	`21`	`+ connectionOptions.ConnectionString,`
	`22`	`+ connectionOptions.Container`
	`23`	`+ );`
`17`	`24`
`18`		`- public Task DeleteAsync(string blob, CancellationToken cancellationToken = default)`
`19`		`- {`
`20`		`- throw new System.NotImplementedException();`
	`25`	`+ _blobContainerClient.CreateIfNotExists(PublicAccessType.BlobContainer);`
`21`	`26`	`}`
`22`	`27`
`23`		`- public Task DeleteAsync(Blob blob, CancellationToken cancellationToken = default)`
	`28`	`+ public void Dispose()`
`24`	`29`	`{`
`25`		`- throw new System.NotImplementedException();`
`26`	`30`	`}`
`27`	`31`
`28`		`- public Task DeleteAsync(IEnumerable<string> blobs, CancellationToken cancellationToken = default)`
`29`		`- {`
`30`		`- throw new System.NotImplementedException();`
`31`		`- }`
	`32`	`+ #region Delete`
`32`	`33`
`33`		`- public Task DeleteAsync(IEnumerable<Blob> blobs, CancellationToken cancellationToken = default)`
	`34`	`+ public async Task DeleteAsync(string blob, CancellationToken cancellationToken = default)`
`34`	`35`	`{`
`35`		`- throw new System.NotImplementedException();`
	`36`	`+ var blobClient = _blobContainerClient.GetBlobClient(blob);`
	`37`	`+ await blobClient.DeleteAsync(DeleteSnapshotsOption.None, null, cancellationToken);`
`36`	`38`	`}`
`37`	`39`
`38`		`- public void Dispose()`
	`40`	`+ public async Task DeleteAsync(Blob blob, CancellationToken cancellationToken = default)`
`39`	`41`	`{`
`40`		`- throw new System.NotImplementedException();`
	`42`	`+ var blobClient = _blobContainerClient.GetBlobClient(blob.Name);`
	`43`	`+ await blobClient.DeleteAsync(DeleteSnapshotsOption.None, null, cancellationToken);`
`41`	`44`	`}`
`42`	`45`
`43`		`- public Task<Stream> DownloadAsStreamAsync(string blob, CancellationToken cancellationToken = default)`
	`46`	`+ public async Task DeleteAsync(IEnumerable<string> blobs, CancellationToken cancellationToken = default)`
`44`	`47`	`{`
`45`		`- throw new System.NotImplementedException();`
	`48`	`+ foreach (var blobName in blobs)`
	`49`	`+ {`
	`50`	`+ await DeleteAsync(blobName, cancellationToken);`
	`51`	`+ }`
`46`	`52`	`}`
`47`	`53`
`48`		`- public Task<Stream> DownloadAsStreamAsync(Blob blob, CancellationToken cancellationToken = default)`
	`54`	`+ public async Task DeleteAsync(IEnumerable<Blob> blobs, CancellationToken cancellationToken = default)`
`49`	`55`	`{`
`50`		`- throw new System.NotImplementedException();`
	`56`	`+ foreach (var blob in blobs)`
	`57`	`+ {`
	`58`	`+ await DeleteAsync(blob, cancellationToken);`
	`59`	`+ }`
`51`	`60`	`}`
`52`	`61`
`53`		`- public Task<LocalFile> DownloadAsync(string blob, CancellationToken cancellationToken = default)`
	`62`	`+ #endregion`
	`63`	`+`
	`64`	`+ public async Task<Stream> DownloadAsStreamAsync(string blob, CancellationToken cancellationToken = default)`
`54`	`65`	`{`
`55`		`- throw new System.NotImplementedException();`
	`66`	`+ var blobClient = _blobContainerClient.GetBlobClient(blob);`
	`67`	`+ var res = await blobClient.DownloadStreamingAsync();`
	`68`	`+`
	`69`	`+ return res.Value.Content;`
`56`	`70`	`}`
`57`	`71`
`58`		`- public Task<LocalFile> DownloadAsync(Blob blob, CancellationToken cancellationToken = default)`
	`72`	`+ public async Task<Stream> DownloadAsStreamAsync(Blob blob, CancellationToken cancellationToken = default)`
`59`	`73`	`{`
`60`		`- throw new System.NotImplementedException();`
	`74`	`+ return await DownloadAsStreamAsync(blob.Name, cancellationToken);`
`61`	`75`	`}`
`62`	`76`
`63`		`- public Task<bool> ExistsAsync(string blob, CancellationToken cancellationToken = default)`
	`77`	`+ public async Task<LocalFile> DownloadAsync(string blob, CancellationToken cancellationToken = default)`
`64`	`78`	`{`
`65`		`- throw new System.NotImplementedException();`
	`79`	`+ var blobClient = _blobContainerClient.GetBlobClient(blob);`
	`80`	`+ var localFile = new LocalFile();`
	`81`	`+`
	`82`	`+ await blobClient.DownloadToAsync(localFile.FileStream, cancellationToken);`
	`83`	`+`
	`84`	`+ return localFile;`
`66`	`85`	`}`
`67`	`86`
`68`		`- public Task<bool> ExistsAsync(Blob blob, CancellationToken cancellationToken = default)`
	`87`	`+ public async Task<LocalFile> DownloadAsync(Blob blob, CancellationToken cancellationToken = default)`
`69`	`88`	`{`
`70`		`- throw new System.NotImplementedException();`
	`89`	`+ return await DownloadAsync(blob.Name, cancellationToken);`
`71`	`90`	`}`
`72`	`91`
`73`		`- public IAsyncEnumerable<bool> ExistsAsync(IEnumerable<string> blobs, CancellationToken cancellationToken = default)`
	`92`	`+ #region Exists`
	`93`	`+`
	`94`	`+ public async Task<bool> ExistsAsync(string blob, CancellationToken cancellationToken = default)`
`74`	`95`	`{`
`75`		`- throw new System.NotImplementedException();`
	`96`	`+ var blobClient = _blobContainerClient.GetBlobClient(blob);`
	`97`	`+`
	`98`	`+ return await blobClient.ExistsAsync(cancellationToken);`
`76`	`99`	`}`
`77`	`100`
`78`		`- public IAsyncEnumerable<bool> ExistsAsync(IEnumerable<Blob> blobs, CancellationToken cancellationToken = default)`
	`101`	`+ public async Task<bool> ExistsAsync(Blob blob, CancellationToken cancellationToken = default)`
`79`	`102`	`{`
`80`		`- throw new System.NotImplementedException();`
	`103`	`+ var blobClient = _blobContainerClient.GetBlobClient(blob.Name);`
	`104`	`+`
	`105`	`+ return await blobClient.ExistsAsync(cancellationToken);`
`81`	`106`	`}`
`82`	`107`
`83`		`- public IAsyncEnumerable<Blob> GetBlob(string blob, CancellationToken cancellationToken = default)`
	`108`	`+ public async IAsyncEnumerable<bool> ExistsAsync(IEnumerable<string> blobs,`
	`109`	`+ [EnumeratorCancellation] CancellationToken cancellationToken = default)`
`84`	`110`	`{`
`85`		`- throw new System.NotImplementedException();`
	`111`	`+ foreach(var blob in blobs)`
	`112`	`+ {`
	`113`	`+ var blobClient = _blobContainerClient.GetBlobClient(blob);`
	`114`	`+ yield return await blobClient.ExistsAsync(cancellationToken);`
	`115`	`+ }`
`86`	`116`	`}`
`87`	`117`
`88`		`- public IAsyncEnumerable<Blob> GetBlob(Blob blob, CancellationToken cancellationToken = default)`
	`118`	`+ public async IAsyncEnumerable<bool> ExistsAsync(IEnumerable<Blob> blobs,`
	`119`	`+ [EnumeratorCancellation] CancellationToken cancellationToken = default)`
`89`	`120`	`{`
`90`		`- throw new System.NotImplementedException();`
	`121`	`+ foreach (var blob in blobs)`
	`122`	`+ {`
	`123`	`+ var blobClient = _blobContainerClient.GetBlobClient(blob.Name);`
	`124`	`+ yield return await blobClient.ExistsAsync(cancellationToken);`
	`125`	`+ }`
`91`	`126`	`}`
`92`	`127`
`93`		`- public IAsyncEnumerable<Blob> GetBlob(IEnumerable<string> blobs, CancellationToken cancellationToken = default)`
	`128`	`+ #endregion`
	`129`	`+`
	`130`	`+ public async Task<Blob> GetBlobAsync(string blob, CancellationToken cancellationToken = default)`
`94`	`131`	`{`
`95`		`- throw new System.NotImplementedException();`
	`132`	`+ await Task.Yield();`
	`133`	`+`
	`134`	`+ var blobClient = _blobContainerClient.GetBlobClient(blob);`
	`135`	`+`
	`136`	`+ return new Blob()`
	`137`	`+ {`
	`138`	`+ Name = blobClient.Name,`
	`139`	`+ Uri = blobClient.Uri`
	`140`	`+ };`
`96`	`141`	`}`
`97`	`142`
`98`		`- public IAsyncEnumerable<Blob> GetBlob(IEnumerable<Blob> blobs, CancellationToken cancellationToken = default)`
	`143`	`+ public IAsyncEnumerable<Blob> GetBlobsAsync(IEnumerable<string> blobs, CancellationToken cancellationToken = default)`
`99`	`144`	`{`
`100`	`145`	`throw new System.NotImplementedException();`
`101`	`146`	`}`
`@@ -105,24 +150,34 @@ public IAsyncEnumerable<Blob> GetBlobListAsync(CancellationToken cancellationTok`
`105`	`150`	`throw new System.NotImplementedException();`
`106`	`151`	`}`
`107`	`152`
`108`		`- public Task UploadAsync(string blob, Stream dataStream, bool append = false, CancellationToken cancellationToken = default)`
	`153`	`+ #region Upload`
	`154`	`+`
	`155`	`+ public async Task UploadAsync(string blob, Stream dataStream, bool append = false, CancellationToken cancellationToken = default)`
`109`	`156`	`{`
`110`		`- throw new System.NotImplementedException();`
	`157`	`+ var blobClient = _blobContainerClient.GetBlobClient(blob);`
	`158`	`+ await blobClient.UploadAsync(dataStream, cancellationToken);`
`111`	`159`	`}`
`112`	`160`
`113`		`- public Task UploadAsync(string blob, string pathToFile, bool append = false, CancellationToken cancellationToken = default)`
	`161`	`+ public async Task UploadAsync(string blob, string pathToFile, bool append = false, CancellationToken cancellationToken = default)`
`114`	`162`	`{`
`115`		`- throw new System.NotImplementedException();`
	`163`	`+ var blobClient = _blobContainerClient.GetBlobClient(blob);`
	`164`	`+`
	`165`	`+ using (var fs = new FileStream(pathToFile, FileMode.Open, FileAccess.Read))`
	`166`	`+ {`
	`167`	`+ await blobClient.UploadAsync(fs, cancellationToken);`
	`168`	`+ }`
`116`	`169`	`}`
`117`	`170`
`118`		`- public Task UploadAsync(Blob blob, Stream dataStream, bool append = false, CancellationToken cancellationToken = default)`
	`171`	`+ public async Task UploadAsync(Blob blob, Stream dataStream, bool append = false, CancellationToken cancellationToken = default)`
`119`	`172`	`{`
`120`		`- throw new System.NotImplementedException();`
	`173`	`+ await UploadAsync(blob.Name, dataStream, append, cancellationToken);`
`121`	`174`	`}`
`122`	`175`
`123`		`- public Task UploadAsync(Blob blob, string pathToFile, bool append = false, CancellationToken cancellationToken = default)`
	`176`	`+ public async Task UploadAsync(Blob blob, string pathToFile, bool append = false, CancellationToken cancellationToken = default)`
`124`	`177`	`{`
`125`		`- throw new System.NotImplementedException();`
	`178`	`+ await UploadAsync(blob.Name, pathToFile, append, cancellationToken);`
`126`	`179`	`}`
	`180`	`+`
	`181`	`+ #endregion`
`127`	`182`	`}`
`128`	`183`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`using ManagedCode.Storage.Core.Builders;`
`4`	`4`	`using ManagedCode.Storage.Core.Helpers;`
`5`	`5`	`using ManagedCode.Storage.Core;`
	`6`	`+using ManagedCode.Storage.Azure.Options;`
`6`	`7`
`7`	`8`	`namespace ManagedCode.Storage.Azure.Extensions`
`8`	`9`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-namespace ManagedCode.Storage.Azure`
	`1`	`+namespace ManagedCode.Storage.Azure.Options`
`2`	`2`	`{`
`3`	`3`	`public class AzureBlobStorageConnectionOptions`
`4`	`4`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,10 @@`
`1`		`-namespace ManagedCode.Storage.Core.Models`
	`1`	`+using System;`
	`2`	`+`
	`3`	`+namespace ManagedCode.Storage.Core.Models`
`2`	`4`	`{`
`3`	`5`	`public class Blob`
`4`	`6`	`{`
`5`		`- public string Path { get; set; }`
	`7`	`+ public string Name { get; set; }`
	`8`	`+ public Uri Uri { get; set; }`
`6`	`9`	`}`
`7`	`10`	`}`