public static async Task <int> SendToAzure(AzureOptions opts)
{
CloudBlockBlob zipSnapshot = null;
CloudBlockBlob zipBlob = null;
try
{
var zipFile = CreateZipFile(opts.Source, opts);
Console.WriteLine("Upload zip file.");
var storageCredentials = new StorageCredentials(opts.AccountName, opts.AccountKey);
var cloudStorageAccount = new CloudStorageAccount(storageCredentials, true);
var cloudBlobClient = cloudStorageAccount.CreateCloudBlobClient();
var container = cloudBlobClient.GetContainerReference(opts.ContainerName);
await container.CreateIfNotExistsAsync();
zipBlob = container.GetBlockBlobReference(opts.Destination + "/software.zip");
if (await zipBlob.ExistsAsync())
{
zipSnapshot = await zipBlob.CreateSnapshotAsync();
}
await zipBlob.UploadFromFileAsync(zipFile);
Console.WriteLine("Update version.");
var xmlBlob = container.GetBlockBlobReference(opts.Destination + "/software.xml");
var doc = CreateOrUpdateVersionFile(
(await xmlBlob.ExistsAsync()) ? XDocument.Parse(await xmlBlob.DownloadTextAsync()) : null,
zipFile,
opts
);
//if (await xmlBlob.ExistsAsync())
// await xmlBlob.CreateSnapshotAsync();
await xmlBlob.UploadTextAsync(doc.ToString());
await zipSnapshot?.DeleteAsync();
File.Delete(zipFile);
return(0);
}
catch (Exception ex)
{
if (zipBlob != null && zipSnapshot != null)
{
await zipBlob.StartCopyAsync(zipSnapshot);
await zipSnapshot.DeleteAsync();
}
Console.WriteLine(ex.Message);
return(1);
}
}
public async Task DeleteAsync()
{
try
{
await _Blob.DeleteAsync().ConfigureAwait(false);
}
catch (StorageException ex)
{
if (ex.RequestInformation != null && ex.RequestInformation.HttpStatusCode == 404)
{
return;
}
throw;
}
}
public async Task DeleteBlob(string blobName)
{
CloudBlobContainer container = this.GetCloudBlobContainer();
CloudBlockBlob blockBlob = container.GetBlockBlobReference(blobName);
try
{
await blockBlob.DeleteAsync();
}
catch (StorageException)
{
throw new AzureXStoreException("The blob is not in the database.");
}
}
public async Task <bool> DeleteContent(string key)
{
try
{
blockBlob = blobContainer.GetBlockBlobReference(key);
await blockBlob.DeleteAsync();
return(true);
}
catch (Exception)
{
//TODO: Logs an error
}
return(false);
}
public async Task DeleteImageFromStorageAsync(string pointId)
{
try
{
StringBuilder fileName = new StringBuilder(pointId);
fileName.Append(SignatureConstants.JPG);
CloudBlockBlob cloudBlockBlob = cloudBlobContainer.GetBlockBlobReference(fileName.ToString());
await cloudBlockBlob.DeleteAsync();
}
catch (Exception ex)
{
throw (ex);
}
}
public async static Task DeleteImagesAsync(
[QueueTrigger("deleterequest")] BlobInfo blobInfo,
[Blob(BlobInfo.ImageNameLg)] CloudBlockBlob blobLarge,
[Blob(BlobInfo.ImageNameXs)] CloudBlockBlob blobExtraSmall,
[Blob(BlobInfo.ImageNameSm)] CloudBlockBlob blobSmall,
[Blob(BlobInfo.ImageNameMd)] CloudBlockBlob blobMedium)
{
await blobExtraSmall.DeleteAsync();
await blobSmall.DeleteAsync();
await blobMedium.DeleteAsync();
await blobLarge.DeleteAsync();
}
// Deletes file(s) or folder(s)
protected async Task <FileManagerResponse> RemoveAsync(string[] names, string path, params FileManagerDirectoryContent[] selectedItems)
{
FileManagerResponse removeResponse = new FileManagerResponse();
List <FileManagerDirectoryContent> details = new List <FileManagerDirectoryContent>();
CloudBlobDirectory directory = (CloudBlobDirectory)item;
FileManagerDirectoryContent entry = new FileManagerDirectoryContent();
CloudBlobDirectory sampleDirectory = container.GetDirectoryReference(path);
foreach (FileManagerDirectoryContent FileItem in selectedItems)
{
if (FileItem.IsFile)
{
path = this.FilesPath.Replace(this.BlobPath, "") + FileItem.FilterPath;
CloudBlockBlob blockBlob = container.GetBlockBlobReference(path + FileItem.Name);
await blockBlob.DeleteAsync();
entry.Name = FileItem.Name;
entry.Type = FileItem.Type;
entry.IsFile = FileItem.IsFile;
entry.Size = FileItem.Size;
entry.HasChild = FileItem.HasChild;
entry.FilterPath = path;
details.Add(entry);
}
else
{
path = this.FilesPath.Replace(this.BlobPath, "") + FileItem.FilterPath;
CloudBlobDirectory subDirectory = container.GetDirectoryReference(path + FileItem.Name);
BlobResultSegment items = await AsyncReadCall(path + FileItem.Name, "Remove");
foreach (IListBlobItem item in items.Results)
{
CloudBlockBlob blockBlob = container.GetBlockBlobReference(path + FileItem.Name + "/" + item.Uri.ToString().Replace(subDirectory.Uri.ToString(), ""));
await blockBlob.DeleteAsync();
entry.Name = FileItem.Name;
entry.Type = FileItem.Type;
entry.IsFile = FileItem.IsFile;
entry.Size = FileItem.Size;
entry.HasChild = FileItem.HasChild;
entry.FilterPath = path;
details.Add(entry);
}
}
}
removeResponse.Files = (IEnumerable <FileManagerDirectoryContent>)details;
return(removeResponse);
}
private async Task CloneAsync(ITemplatesProvider sourceProvider, string path, IEnumerable <ITemplateItem> items, Action <string> log)
{
HashSet <ITemplateItem> existingItems = new HashSet <ITemplateItem>(await GetAsync(path, log));
// Add or update the items
foreach (ITemplateItem item in items)
{
log?.Invoke($"Cloning: {item.Path}");
// Mark as done
if (!existingItems.Remove(item))
{
existingItems.RemoveWhere(i => i.Path == System.Uri.EscapeUriString(item.Path));
}
if (item is ITemplateFolder folder)
{
// Get the children and clone the entire folder
IEnumerable <ITemplateItem> folderItems = await sourceProvider.GetAsync(folder.Path, log);
await CloneAsync(sourceProvider, folder.Path, folderItems, log);
}
else if (item is ITemplateFile file)
{
using (Stream sourceStream = await file.DownloadAsync())
{
CloudBlockBlob blob = _container.GetBlockBlobReference(item.Path);
await blob.UploadFromStreamAsync(sourceStream);
}
}
}
// Remove any additional item
foreach (ITemplateItem item in existingItems)
{
log?.Invoke($"Removing: {item.Path}");
if (item is ITemplateFolder folder)
{
// To remove a directory we need to iterate through children
await DeleteDirectoryAsync(item.Path, log);
}
else if (item is ITemplateFile file)
{
CloudBlockBlob blob = _container.GetBlockBlobReference(System.Uri.UnescapeDataString(item.Path));
await blob.DeleteAsync();
}
}
}
private async Task <bool> AzureDelete(string key)
{
try
{
CloudBlockBlob blockBlob = _AzureContainer.GetBlockBlobReference(key);
OperationContext ctx = new OperationContext();
await blockBlob.DeleteAsync(DeleteSnapshotsOption.None, null, null, ctx);
int statusCode = ctx.LastResult.HttpStatusCode;
return(true);
}
catch (Exception)
{
return(false);
}
}
public async Task <IActionResult> DeleteConfirmed(int id)
{
var Flower = await _context.Flower.FindAsync(id);
CloudBlobContainer container = GetCloudBlobContainer();
if (Flower.ImageRef != null)
{
CloudBlockBlob blob = container.GetBlockBlobReference(Flower.ImageRef);
blob.DeleteAsync().Wait();
}
_context.Flower.Remove(Flower);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public async void DeleteBlobData(string fileUrl)
{
Uri uriObj = new Uri(fileUrl);
string BlobName = Path.GetFileName(uriObj.LocalPath);
CloudBlobContainer cloudBlobContainer =
GetBlobContainer(_accessKey, _defaultContainerName);
string pathPrefix = DateTime.Now.ToUniversalTime().ToString("yyyy-MM-dd") + "/";
CloudBlobDirectory blobDirectory = cloudBlobContainer.GetDirectoryReference(pathPrefix);
// get block blob
CloudBlockBlob blockBlob = blobDirectory.GetBlockBlobReference(BlobName);
// delete blob from container
await blockBlob.DeleteAsync();
}
public async Task DeleteImage(string imageId)
{
try
{
CloudBlockBlob cloudBlockBlob = _profilePicturesContainer.GetBlockBlobReference(imageId);
if (!await cloudBlockBlob.ExistsAsync())
{
throw new ProfilePictureNotFoundException("Profile Picture not found");
}
await cloudBlockBlob.DeleteAsync();
}
catch (StorageException e)
{
throw new StorageException("Could not delete from blob", e);
}
}
public static async Task Run(
[QueueTrigger(QueueName.RenderPage)] RenderPage command,
[Blob(ContainerName.PageTemplate + "/{" + nameof(RenderPage.TemplateId) + "}", FileAccess.Read)] CloudBlockBlob pageTemplateBlob,
[Blob(ContainerName.PageData + "/{" + nameof(RenderPage.DataInstanceId) + "}", FileAccess.ReadWrite)] CloudBlockBlob pageDataBlob,
[Blob(ContainerName.WebHost + "/{" + nameof(RenderPage.PublicUrl) + "}", FileAccess.Write)] CloudBlockBlob pageHtmlBlob,
[Queue(QueueName.CopyBlob)] CloudQueue copyQueue,
ILogger log)
{
log.LogInformation(JsonConvert.SerializeObject(command));
var copyQueueService = new CommandQueueService(copyQueue);
var pageData = JsonConvert.DeserializeObject(await pageDataBlob.DownloadTextAsync());
var pageTemplate = await pageTemplateBlob.DownloadTextAsync();
var html = Render.StringToString(pageTemplate, pageData, new RenderContextBehaviour
{
HtmlEncoder = text => text
});
var compressor = new HtmlCompressor();
compressor.setEnabled(true);
compressor.setRemoveComments(true);
compressor.setRemoveMultiSpaces(true);
compressor.setRemoveIntertagSpaces(true);
html = compressor.compress(html);
await pageHtmlBlob.UploadTextAsync(html);
pageHtmlBlob.Properties.ContentType = "text/html";
await pageHtmlBlob.SetPropertiesAsync();
var copyCommand = new CopyBlob
{
Path = command.PublicUrl
};
await Task.WhenAll(
pageDataBlob.DeleteAsync(),
copyQueueService.SubmitCommandAsync(copyCommand)
);
}
public IActionResult DeleteFileNow(string fileName, int BlogPostId)
{
var storageAccount = CloudStorageAccount.Parse("DefaultEndpointsProtocol=https;AccountName=blogster;AccountKey=2pvh1PnvLjjAj8BG1fKfI05YQs49r0Vpo4Qv7HDVrUhwRY0w5jHVXKvQYUqgRLRDfuyIiyEi9qCTjvWGk1/RNA==");
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference("imageblogs");
CloudBlockBlob blockBlob = container.GetBlockBlobReference(fileName);
blockBlob.DeleteAsync();
var fileToDelete = (from f in _blogsterDataContext.Photos where (f.Filename == fileName & f.BlogPostId == BlogPostId) select f).FirstOrDefault();
_blogsterDataContext.Remove(fileToDelete);
_blogsterDataContext.SaveChanges();
return(RedirectToAction("Index"));
}
public void DeleteFromBlob(string filename)
{
// Retrieve storage account from connection string.
CloudStorageAccount storageAccount = CloudStorageAccount.Parse("DefaultEndpointsProtocol=https;AccountName=datossensores;AccountKey=x7W/PW86xtAuEJv+aOwyIYiG1dHC0+8EX3GP2ktC39B94ppau5PodjNvf+3NXsoG5/On6kJIQ9T2EtM5+HtAXA==");
// Create the blob client.
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
// Retrieve reference to a previously created container.
CloudBlobContainer container = blobClient.GetContainerReference("imagenaparatos");
// Retrieve reference to a blob named "myblob.csv".
CloudBlockBlob blockBlob = container.GetBlockBlobReference(filename);
// Delete the blob.
blockBlob.DeleteAsync();
}
public async void DeleteBlobData(string fileUrl)
{
Uri relativeUri = new Uri(fileUrl, UriKind.Relative);
string BlobName = Path.GetFileName(relativeUri.ToString());
// Parse the storage account access key
CloudStorageAccount cloudStorageAccount = CloudStorageAccount.Parse(_settings.ConnectionString);
CloudBlobClient cloudBlobClient = cloudStorageAccount.CreateCloudBlobClient();
string strContainerName = _settings.BlobStorageContainer;
// Get reference to blob container
CloudBlobContainer cloudBlobContainer = cloudBlobClient.GetContainerReference(strContainerName);
CloudBlobDirectory blobDirectory = cloudBlobContainer.GetDirectoryReference("");
// Get reference to blob
CloudBlockBlob blockBlob = blobDirectory.GetBlockBlobReference(fileUrl);
//Delete blob from container
await blockBlob.DeleteAsync();
}
public async Task DeletePostByIdAsync(string postId, CancellationToken cancellationToken = default)
{
CloudBlockBlob blob = _postsContainer.GetBlockBlobReference(GetPostBlobName(postId));
if (await blob.ExistsAsync(null, null, cancellationToken))
{
await blob.DeleteAsync(DeleteSnapshotsOption.None,
null,
null,
null,
cancellationToken);
}
await _cacheService.RemoveAsync <Post>(postId, cancellationToken);
await UpdatePostCategoriesAsync(new PostBase { Id = postId }, true, cancellationToken);
}
public static async Task Run([TimerTrigger("0 */5 * * * *")] TimerInfo myTimer, ILogger log)
{
string output = string.Empty;
var inputcontainer = client.GetContainerReference("liquid-transforms-input");
var blobs = GetBlobs(inputcontainer).Result;
foreach (var item in blobs)
{
CloudBlockBlob inputblob = inputcontainer.GetBlockBlobReference(item.Name);
string inputxml = await inputblob.DownloadTextAsync();
output = await GetTransformedxml(inputxml);
await UploadBlob(output, item.Name);
await inputblob.DeleteAsync();
}
}
public bool DeleteBlob(string url)
{
bool check;
try
{
Uri uri = new Uri(url);
CloudBlockBlob blob = new CloudBlockBlob(uri);
blob.DeleteAsync();
check = blob.IsDeleted;
}
catch (Exception)
{
throw;
}
return(check);
}
public async Task DeleteFile(string shareName, string folder, string fileName)
{
try
{
CloudBlockBlob cloudBlockBlob = await this.GetBlobReference(folder, fileName);
await cloudBlockBlob.DeleteAsync();
}
catch (StorageException exStorage)
{
this.ErrorMessage = exStorage.ToString();
}
catch (Exception ex)
{
this.ErrorMessage = ex.ToString();
}
}
/// <summary>
/// Waits for all expected blocks to finish uploading, commits the blob, then deletes the blob and container used during the test.
/// </summary>
/// <remarks>This method will only be called if application is running as ID 0.</remarks>
/// <param name="container">The blob's container.</param>
/// <param name="blobName">The name of the blob being uploaded.</param>
/// <param name="totalBlocks">The total number of blocks to commit to the blob.</param>
private static async Task FinalizeBlob(CloudBlobContainer container, string blobName, uint totalBlocks, bool cleanup)
{
// Define the order in which to commit blocks.
List <string> blockIdList = new List <string>();
for (uint i = 0; i < totalBlocks; ++i)
{
blockIdList.Add(Convert.ToBase64String(BitConverter.GetBytes(i)));
}
HashSet <string> blockIdSet = new HashSet <string>(blockIdList);
CloudBlockBlob blockblob = container.GetBlockBlobReference(blobName);
// Poll the blob's Uncommitted Block List until we determine that all expected blocks have been successfully uploaded.
Console.WriteLine("Waiting for all expected blocks to appear in the uncommitted block list.");
IEnumerable <ListBlockItem> currentUncommittedBlockList = new List <ListBlockItem>();
while (true)
{
currentUncommittedBlockList = await blockblob.DownloadBlockListAsync(BlockListingFilter.Uncommitted, AccessCondition.GenerateEmptyCondition(), null, null);
if (currentUncommittedBlockList.Count() >= blockIdList.Count &&
VerifyBlocks(currentUncommittedBlockList, blockIdSet))
{
break;
}
Console.WriteLine($"{currentUncommittedBlockList.Count()} / {blockIdList.Count} blocks in the uncommitted block list.");
await Task.Delay(TimeSpan.FromSeconds(5));
}
Console.WriteLine("Issuing PutBlockList.");
await blockblob.PutBlockListAsync(blockIdList);
if (cleanup)
{
Console.WriteLine("Press 'Enter' key to delete the example container and blob.");
Console.ReadLine();
Console.WriteLine("Issuing DeleteBlob.");
await blockblob.DeleteAsync();
Console.WriteLine("Deleting container.");
await container.DeleteAsync();
}
}
/// <summary>
/// Adds a file to the user's tenant container in the repository. An owner file permission record is also created allowing all WOPI operations.
/// </summary>
/// <param name="userId">UserID of the file owner</param>
/// <param name="stream">Stream containing file contents</param>
/// <param name="fileName">Name of file with extension</param>
/// <returns>Returns a string with unique FileID identifier, which is unique across the repository</returns>
public async Task <WopiFile> AddFile(string userId, string tenant, Stream stream, string fileName)
{
var fileId = Guid.NewGuid().ToString();
CloudBlockBlob blockBlob = null;
try
{
using (var wopiContext = new WopiContext())
{
var existingFiles = await wopiContext.Files.Where(f => f.FileName == fileName && f.Container == tenant).ToListAsync();
var storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString"));
var blobClient = storageAccount.CreateCloudBlobClient();
var containerName = tenant.ToLower(); // blob containers must be lowercase
var container = blobClient.GetContainerReference(containerName);
await container.CreateIfNotExistsAsync();
blockBlob = container.GetBlockBlobReference(fileId);
await blockBlob.UploadFromStreamAsync(stream);
int newVersion = 1;
if (existingFiles.Count() > 0)
{
var versions = existingFiles.Select(file => file.Version);
var maxVersion = versions.Max();
newVersion = maxVersion + 1;
}
var wopiFile = CreateOwnerRecords(fileName, userId, blockBlob, newVersion);
wopiContext.Files.Add(wopiFile);
await wopiContext.SaveChangesAsync();
return(wopiFile);
}
}
catch (Exception ex)
{
if (blockBlob != null && await blockBlob.ExistsAsync())
{
await blockBlob.DeleteAsync();
}
throw;
}
}
public async void DeleteBlobData(string fileUrl)
{
Uri uriObj = new Uri(fileUrl);
string BlobName = Path.GetFileName(uriObj.LocalPath);
CloudStorageAccount cloudStorageAccount = CloudStorageAccount.Parse(accessKey);
CloudBlobClient cloudBlobClient = cloudStorageAccount.CreateCloudBlobClient();
string strContainerName = "fileconatiner";
CloudBlobContainer cloudBlobContainer = cloudBlobClient.GetContainerReference(strContainerName);
string pathPrefix = DateTime.Now.ToUniversalTime().ToString("yyyy-MM-dd") + "/";
CloudBlobDirectory blobDirectory = cloudBlobContainer.GetDirectoryReference(pathPrefix);
// get block blob refarence
CloudBlockBlob blockBlob = blobDirectory.GetBlockBlobReference(BlobName);
// delete blob from container
await blockBlob.DeleteAsync();
}
public async Task DeleteFileFromBlobAsync(string ContainerName, string ResourceName)
{
try
{
//1) Get Blob Container Reference
CloudBlobContainer blobContainer = _cloudBlobClient.GetContainerReference(ContainerName);
//2) Get Resource Reference
CloudBlockBlob _blockBlob = blobContainer.GetBlockBlobReference(ResourceName);
//3) Delete resource from Blob Container
await _blockBlob.DeleteAsync();
}
catch (Exception)
{
throw;
}
}
public async Task DeleteDocAsync(string filename)
{
var strorageconn = _appSettings.AzureDataStorageConnection;
CloudStorageAccount storageacc = CloudStorageAccount.Parse(strorageconn);
//Create Reference to Azure Blob
CloudBlobClient blobClient = storageacc.CreateCloudBlobClient();
//The next 2 lines create if not exists a container named "democontainer"
CloudBlobContainer container = blobClient.GetContainerReference("quotes");
await container.CreateIfNotExistsAsync();
//The next 7 lines upload the file test.txt with the name DemoBlob on the container "democontainer"
CloudBlockBlob blockBlob = container.GetBlockBlobReference(filename);
await blockBlob.DeleteAsync();
}
static async Task DeleteBlob(CloudBlobContainer blobContainer, string blobName)
{
// Get Blob reference using the container reference previously created
CloudBlockBlob blockBlob = blobContainer.GetBlockBlobReference(blobName);
try
{
// Delete Blob
await blockBlob.DeleteAsync();
Console.WriteLine("Blob {0} deleted successfully from container {1}", blobName, blobContainer.Name);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.WriteLine();
}
public async void DeleteBlob()
{
// Retrieve storage account from connection string.
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(
CloudConfigurationManager.GetSetting("StorageConnectionString"));
// Create the blob client.
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
// Retrieve reference to a previously created container.
CloudBlobContainer container = blobClient.GetContainerReference("mycontainer");
// Retrieve reference to a blob named "myblob.txt".
CloudBlockBlob blockBlob = container.GetBlockBlobReference("myblob.txt");
// Delete the blob.
await blockBlob.DeleteAsync();
}
public async Task DeleteBlobStorageAsync(string url)
{
try
{
// get the container reference
var container = GetImagesBlobContainer();
var blobName = url.Split('/').Last();
// using the container reference, get a block blob reference and set its type
CloudBlockBlob blockBlob = container.GetBlockBlobReference($"{_petPicturesBlobName}/{blobName}");
// finally, upload the image into blob storage using the block blob reference
await blockBlob.DeleteAsync();
}
catch (Exception)
{
}
}
public static async Task <bool> DeleteBlobAsync(string fileName)
{
try
{
CloudStorageAccount cloudStorageAccount = CloudStorageAccount.Parse(connectionString);
CloudBlobClient _blobClient = cloudStorageAccount.CreateCloudBlobClient();
CloudBlobContainer _cloudBlobContainer = _blobClient.GetContainerReference(containerName);
CloudBlockBlob _blockBlob = _cloudBlobContainer.GetBlockBlobReference(fileName);
//delete file from container
await _blockBlob.DeleteAsync();
return(true);
}
catch (Exception ex)
{
return(false);
}
}
/// <summary>
/// Basic operations to work with block blobs
/// </summary>
/// <returns>Task<returns>
private static async Task BasicStorageBlockBlobOperations()
{
const string ImageToUpload = "HelloWorld.png";
// Retrieve storage account information from connection string
// How to create a storage connection string - http://msdn.microsoft.com/en-us/library/azure/ee758697.aspx
CloudStorageAccount storageAccount = storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString"));
// Create a blob client for interacting with the blob service.
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
// Create a container for organizing blobs within the storage account.
Console.WriteLine("1. Creating Container");
CloudBlobContainer container = blobClient.GetContainerReference("democontainerblockblob");
await container.CreateIfNotExistsAsync();
// To view the uploaded blob in a browser, you need to set permissions to allow public access to blobs in this container.
// Then you can view the image using: https://[InsertYourStorageAccountNameHere].blob.core.windows.net/democontainer/HelloWorld.png
// await container.SetPermissionsAsync(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob });
// Upload a BlockBlob to the newly creating container
Console.WriteLine("2. Uploading BlockBlob");
CloudBlockBlob blockBlob = container.GetBlockBlobReference(ImageToUpload);
await blockBlob.UploadFromFileAsync(ImageToUpload, FileMode.Open);
// List all the blobs in the container
Console.WriteLine("3. List Blobs in Container");
foreach (IListBlobItem blob in container.ListBlobs())
{
// Blob type will be CloudBlockBlob, CloudPageBlob or CloudBlobDirectory
// Use blob.GetType() and cast to appropriate type to gain access to properties specific to each type
Console.WriteLine("- {0} (type: {1})\n", blob.Uri, blob.GetType());
}
// Download a blob to your file system
Console.WriteLine("4. Download Blob from {0}", blockBlob.Uri.AbsoluteUri);
await blockBlob.DownloadToFileAsync(string.Format("./CopyOf{0}", ImageToUpload), FileMode.Create);
// Clean up after the demo
Console.WriteLine("5. Delete blok Blob and container");
await blockBlob.DeleteAsync();
await container.DeleteAsync();
}
