/// <summary>

    /// Storage service used to store files on azure.

    /// </summary>

    public interface IStorageService

    {

        /// <summary>

        /// Upload public file which will be accessed directly from browser.

        /// </summary>

        /// <param name="containerName">Name of the container.</param>

        /// <param name="file">File details.</param>

        /// <returns>File URL.</returns>

        Task<Uri> UploadPublicFileAsync(string containerName, IFormFile file);

​

        /// <summary>

        /// Upload private file. Which later will be accessed with access token.

        /// </summary>

        /// <param name="containerName">Name of the container.</param>

        /// <param name="file">File details.</param>

        /// <returns>File URL.</returns>

        Task<Uri> UploadAsync(string containerName, IFormFile file);

​

        /// <summary>

        /// Download file.

        /// </summary>

        /// <param name="containerName">Name of the container.</param>

        /// <param name="fileUrl">File URL.</param>

        /// <returns>File stream.</returns>

        Task<Stream> DownloadAsync(string containerName, string fileUrl);

​

        /// <summary>

        /// Delete file.

        /// </summary>

        /// <param name="containerName">Name of the container.</param>

        /// <param name="fileUrl">File URL.</param>

        Task DeleteAsync(string containerName, string fileUrl);

​

        /// <summary>

        /// Get public URL for private blob.

        /// </summary>

        /// <param name="containerName">Name of the container.</param>

        /// <param name="fileUrl">File URL.</param>

        /// <param name="expiryTime">Time when this public URL will be expire.</param>

        /// <returns>Public URL of file.</returns>

        Task<string> GetBlobSasUriAsync(string containerName, string fileUrl, DateTimeOffset? expiryTime);

    }

​

​

​

internal class StorageService : IStorageService

    {

        private readonly CloudBlobClient _blobClient;

        private readonly IConfiguration _configuration;

​

        public StorageService(CloudBlobClient blobClient, IConfiguration configuration)

        {

            _blobClient = blobClient;

            _configuration = configuration;

        }

​

        public async Task<Uri> UploadPublicFileAsync(string containerName, IFormFile file)

        {

            var container = _blobClient.GetContainerReference(containerName);

            await container.CreateIfNotExistsAsync();

​

            var permissions = new BlobContainerPermissions

            {

                PublicAccess = BlobContainerPublicAccessType.Blob

            };

            await container.SetPermissionsAsync(permissions);

​

            var fileName = GetRandomBlobName(file.FileName);

            var blockBlob = container.GetBlockBlobReference(fileName);

            await blockBlob.UploadFromStreamAsync(file.OpenReadStream());

            return blockBlob.Uri;

        }

​

        public async Task<Stream> DownloadAsync(string containerName, string fileUrl)

        {

            Stream fileStream = null;

            var container = _blobClient.GetContainerReference(containerName);

​

            if (await container.ExistsAsync())

            {

                var fileName = GetFileName(fileUrl);

                var file = container.GetBlockBlobReference(fileName);

​

                if (await file.ExistsAsync())

                {

                    var ms = new MemoryStream();

                    await file.DownloadToStreamAsync(ms);

                    fileStream = await file.OpenReadAsync();

                }

            }

            return fileStream;

        }

​

        public async Task DeleteAsync(string containerName, string fileUrl)

        {

            var container = _blobClient.GetContainerReference(containerName);

​

            if (await container.ExistsAsync())

            {

                var fileName = GetFileName(fileUrl);

                var file = container.GetBlockBlobReference(fileName);

                await file.DeleteIfExistsAsync();

            }

        }

​

        public async Task<string> GetBlobSasUriAsync(string containerName, string fileUrl, DateTimeOffset? expiryTime)

        {

            string sasBlobToken = string.Empty;

            var container = _blobClient.GetContainerReference(containerName);

​

            if (await container.ExistsAsync())

            {

                var fileName = GetFileName(fileUrl);

​

                // Get a reference to a blob within the container.

                // Note that the blob may not exist yet, but a SAS can still be created for it.

                var blob = container.GetBlockBlobReference(fileName);

​

                // Create a new access policy and define its constraints.

                // Note that the SharedAccessBlobPolicy class is used both to define the parameters of an ad hoc SAS, and

                // to construct a shared access policy that is saved to the container's shared access policies.

                var sharedAccessBlobPolicy = new SharedAccessBlobPolicy()

                {

                    // When the start time for the SAS is omitted, the start time is assumed to be the time when the storage service receives the request.

                    // Omitting the start time for a SAS that is effective immediately helps to avoid clock skew.

                    SharedAccessExpiryTime = expiryTime?? DateTime.UtcNow.AddHours(_configuration.GetValue<Int32>("SharedAccessExpiryHours")),

                    Permissions = SharedAccessBlobPermissions.Read | SharedAccessBlobPermissions.Write | SharedAccessBlobPermissions.Create

                };

​

                // Generate the shared access signature on the blob, setting the constraints directly on the signature.

                sasBlobToken = blob.GetSharedAccessSignature(sharedAccessBlobPolicy);

            }

​

            // Return the URI string for the container, including the SAS token.

            return fileUrl + sasBlobToken;

        }

​

        private string GetFileName(string fileUrl)

        {

            var uri = new Uri(fileUrl);

            return Path.GetFileName(uri.LocalPath);

        }

​

        private string GetRandomBlobName(string fileName)

        {

            string ext = Path.GetExtension(fileName);

            return $"{Guid.NewGuid()}{ext}";

        }

​

        public async Task<Uri> UploadAsync(string containerName, IFormFile file)

        {

            var container = _blobClient.GetContainerReference(containerName);

            await container.CreateIfNotExistsAsync();

​

            var permissions = new BlobContainerPermissions

            {

                PublicAccess = BlobContainerPublicAccessType.Off

            };

            await container.SetPermissionsAsync(permissions);

​

            var fileName = GetRandomBlobName(file.FileName);

            var blockBlob = container.GetBlockBlobReference(fileName);

            await blockBlob.UploadFromStreamAsync(file.OpenReadStream());

            return blockBlob.Uri;

        }

    }

​

public static IServiceCollection AddStorage(this IServiceCollection services, IConfiguration configuration)

        {

            services.AddSingleton<CloudBlobClient>(_ =>

            {

                return CloudStorageAccount.Parse(configuration["AzureSrorageConnection"]).CreateCloudBlobClient();

            });

            services.AddSingleton<IStorageService, StorageService>();

​

            return services;

        }

​

​

WindowsAzure.Storage