/// <inheritdoc /> public void CopyFile(string sourceFileName, string[] sourceParentDirectories, string targetFileName, string[] targetParentDirectories, bool overwriteIfExists = false) { #region validation if (string.IsNullOrEmpty(sourceFileName)) { throw new ArgumentNullException(nameof(sourceFileName)); } if (string.IsNullOrEmpty(targetFileName)) { throw new ArgumentNullException(nameof(targetFileName)); } #endregion CloudFileDirectory sourceDirectory = CloudFileShare.GetDirectoryReference(path: sourceParentDirectories); CloudFileDirectory targetDirectory = CloudFileShare.GetDirectoryReference(path: targetParentDirectories); CloudFile sourceFile = sourceDirectory.GetFileReference(sourceFileName); CloudFile targetFile = targetDirectory.GetFileReference(targetFileName); if (overwriteIfExists) { TaskUtilities.ExecuteSync(targetFile.DeleteIfExistsAsync()); } if (!TaskUtilities.ExecuteSync(targetFile.ExistsAsync())) { TaskUtilities.ExecuteSync(targetFile.StartCopyAsync(sourceFile)); } }
public async Task <IActionResult> DeleteConfirmed(string id) { var sampleDataSource = await _context.SampleDataSources.FindAsync(id); CloudStorageAccount storageAccount = CloudStorageAccount.Parse(_configuration.GetConnectionString("StorageConnectionString")); // Create a CloudFileClient object for credentialed access to Azure Files. CloudFileClient fileClient = storageAccount.CreateCloudFileClient(); // Get a reference to the file share we created previously. CloudFileShare cloudFileShare = fileClient.GetShareReference("samples"); await cloudFileShare.CreateIfNotExistsAsync(); CloudFileDirectory cloudFileDirectory = cloudFileShare.GetRootDirectoryReference(); string cloudFilename = sampleDataSource.Uri.Split("/").Last(); CloudFile cloudFile = cloudFileDirectory.GetFileReference(cloudFilename); await cloudFile.DeleteIfExistsAsync(); _context.SampleDataSources.Remove(sampleDataSource); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); }
public async static Task <bool> RemoveFileFromCloudFile(string connectionString, string fileFolder, string filename) { CloudStorageAccount storageAccount = CloudStorageAccount.Parse( connectionString); CloudFileClient fileClient = storageAccount.CreateCloudFileClient(); // Get a reference to the file share we created previously. CloudFileShare share = fileClient.GetShareReference(fileFolder); CloudFileDirectory userDir = null; // Ensure that the share exists. if (await share.ExistsAsync()) { // Get a reference to the root directory for the share. CloudFileDirectory rootDir = share.GetRootDirectoryReference(); // Get a reference to the directory we created previously. userDir = rootDir.GetDirectoryReference("audio"); // Ensure that the directory exists. if (await userDir.ExistsAsync()) { CloudFile removefile = userDir.GetFileReference(filename); await removefile.DeleteIfExistsAsync(); return(true); } else { return(false); } } else { return(false); } }
public async Task <ActionResult> DeleteFile(string fileName) { CloudFileDirectory dir = share.GetRootDirectoryReference().GetDirectoryReference(directoryName); CloudFile file = dir.GetFileReference(fileName); await file.DeleteIfExistsAsync(); return(RedirectToAction("Index")); }
public async Task <ActionResult> CreateNewDataSource(MainViewModel main, IFormFile DataFile) { DataSource dataSource = main.SelectedDataSource; dataSource.DataFile = DataFile; if (dataSource == null || dataSource.DataFile == null || dataSource.DataFile.Length == 0) { return(Content("file not selected")); } CloudStorageAccount storageAccount = CloudStorageAccount.Parse(_configuration.GetConnectionString("StorageConnectionString")); // Create a CloudFileClient object for credentialed access to Azure Files. CloudFileClient fileClient = storageAccount.CreateCloudFileClient(); // Get a reference to the file share we created previously. CloudFileShare cloudFileShare = fileClient.GetShareReference(GetCurrentUserAsync().Result.Id); await cloudFileShare.CreateIfNotExistsAsync(); CloudFileDirectory cloudFileDirectory = cloudFileShare.GetRootDirectoryReference(); CloudFile cloudFile = cloudFileDirectory.GetFileReference(dataSource.DataFile.FileName); await cloudFile.DeleteIfExistsAsync(); using (var stream = new MemoryStream()) { await dataSource.DataFile.CopyToAsync(stream); stream.Seek(0, SeekOrigin.Begin); await cloudFile.UploadFromStreamAsync(stream); stream.Seek(0, SeekOrigin.Begin); StreamReader reader = new StreamReader(stream); main.RawData = reader.ReadToEnd(); main.SelectedDataSourceName = dataSource.DataFile.FileName; } dataSource.Uri = cloudFile.Uri.ToString(); dataSource.CreatedBy = GetCurrentUserAsync().Result; dataSource.CreatedDate = System.DateTime.Now; _context.Add(dataSource); await _context.SaveChangesAsync(); main.SelectedDataSourceName = cloudFile.Uri.ToString(); //Copied raw data to processed data in case user skips the pre-processing/cleansing step main.ProcessedData = main.RawData; return(PartialView("~/Views/Main/_DisplayDataSource.cshtml", main)); }
public async Task <IActionResult> Create([Bind("Id,Name,Description,Uri,TypeId,CreatedDate,DataFile")] DataSource dataSource) { if (ModelState.IsValid) { if (dataSource == null || dataSource.DataFile == null || dataSource.DataFile.Length == 0) { return(Content("file not selected")); } CloudStorageAccount storageAccount = CloudStorageAccount.Parse(_configuration.GetConnectionString("StorageConnectionString")); // Create a CloudFileClient object for credentialed access to Azure Files. CloudFileClient fileClient = storageAccount.CreateCloudFileClient(); // Get a reference to the file share we created previously. CloudFileShare cloudFileShare = fileClient.GetShareReference(GetCurrentUserAsync().Result.Id); await cloudFileShare.CreateIfNotExistsAsync(); CloudFileDirectory cloudFileDirectory = cloudFileShare.GetRootDirectoryReference(); CloudFile cloudFile = cloudFileDirectory.GetFileReference(dataSource.DataFile.FileName); await cloudFile.DeleteIfExistsAsync(); using (var stream = new MemoryStream()) { await dataSource.DataFile.CopyToAsync(stream); stream.Seek(0, SeekOrigin.Begin); await cloudFile.UploadFromStreamAsync(stream); } dataSource.Uri = cloudFile.Uri.ToString(); dataSource.CreatedBy = GetCurrentUserAsync().Result; dataSource.CreatedDate = System.DateTime.Now; _context.Add(dataSource); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } var plan = _context.Organizations.Where(y => y.Id == GetCurrentUserAsync().Result.OrganizationId).Select(z => z.SelectedPlanId); var connectors = _context.PlanDataConnectors.Where(y => y.PlanId == plan.First()).Select(z => z.DataSourceConnectorId); var connectorIds = String.Join(',', connectors.ToArray()); ViewBag.AvailableDataConnectors = _context.DataSourceConnectors.Where(y => connectorIds.Contains(y.Id)).ToList(); ViewBag.SelectedDataSource = dataSource; return(View(dataSource)); }
/// <inheritdoc /> public void DeleteFile(string fileName, string[] path) { #region validation if (string.IsNullOrEmpty(fileName)) { throw new ArgumentNullException(nameof(fileName)); } #endregion CloudFileDirectory currentDir = CloudFileShare.GetDirectoryReference(null, path); CloudFile file = currentDir.GetFileReference(fileName); TaskUtilities.ExecuteSync(file.DeleteIfExistsAsync()); }
public async Task <IActionResult> Create([Bind("Id,Name,Description,Uri,TypeId,CreatedDate,DataFile")] SampleDataSource sampleDataSource) { if (ModelState.IsValid) { if (sampleDataSource == null || sampleDataSource.DataFile == null || sampleDataSource.DataFile.Length == 0) { return(Content("file not selected")); } CloudStorageAccount storageAccount = CloudStorageAccount.Parse(_configuration.GetConnectionString("StorageConnectionString")); // Create a CloudFileClient object for credentialed access to Azure Files. CloudFileClient fileClient = storageAccount.CreateCloudFileClient(); // Get a reference to the file share we created previously. CloudFileShare cloudFileShare = fileClient.GetShareReference("samples"); await cloudFileShare.CreateIfNotExistsAsync(); CloudFileDirectory cloudFileDirectory = cloudFileShare.GetRootDirectoryReference(); CloudFile cloudFile = cloudFileDirectory.GetFileReference(sampleDataSource.DataFile.FileName); await cloudFile.DeleteIfExistsAsync(); using (var stream = new MemoryStream()) { await sampleDataSource.DataFile.CopyToAsync(stream); stream.Seek(0, SeekOrigin.Begin); await cloudFile.UploadFromStreamAsync(stream); } sampleDataSource.Uri = cloudFile.Uri.ToString(); sampleDataSource.CreatedBy = GetCurrentUserAsync().Result; sampleDataSource.CreatedDate = System.DateTime.Now; _context.Add(sampleDataSource); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } ViewBag.AvailableDataConnectors = _context.DataSourceConnectors.ToList(); return(View(sampleDataSource)); }
private static async Task UploadFile(CloudFileDirectory destinationFileDirectory, IReader reader, dynamic returnObject) { CloudFile destinationFileReference = destinationFileDirectory.GetFileReference(reader.Entry.Key); await destinationFileReference.DeleteIfExistsAsync(); string tempFileName = GetTempFileName(); try { reader.WriteEntryToFile(tempFileName); await TransferManager.UploadAsync(tempFileName, destinationFileReference); } finally { File.Delete(tempFileName); } returnObject.Output.Add(destinationFileReference.Uri.ToString()); }
public async Task <bool> RenameFile(string originalName, string newName, bool overrideIfExists = false) { CloudFile originalFile = baseDir.GetFileReference(originalName); if (!await originalFile.ExistsAsync()) { return(false); } var newFile = baseDir.GetFileReference(newName); if (await newFile.ExistsAsync() && !overrideIfExists) { return(false); } await newFile.StartCopyAsync(originalFile); await originalFile.DeleteIfExistsAsync(); return(true); }
public void FileOperations(string fileSharename, string Directory, string filePath) { CloudFileClient fileClient = storageAccount.CreateCloudFileClient(); CloudFileShare fileShare = fileClient.GetShareReference(fileSharename); fileShare.CreateIfNotExists(null, null); CloudFileDirectory rootDirectory = fileShare.GetRootDirectoryReference(); CloudFileDirectory fileDirectory = rootDirectory.GetDirectoryReference(Directory); fileDirectory.CreateIfNotExists(); CloudFile file = fileDirectory.GetFileReference("testfile"); //Deleting If File Exists file.DeleteIfExistsAsync(); if (file.Exists() == false) { FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.ReadWrite); file.Create(fs.Length); fs.Close(); } file.OpenWrite(null); //Upload File Operation file.UploadFromFile(filePath, FileMode.Open); //Write File Operation file.WriteRange(new FileStream(filePath, FileMode.Open), 0); Stream azureFile = file.OpenRead(); //Read File Operation azureFile.Position = 0; byte[] buffer = new byte[azureFile.Length - 1]; int n = azureFile.Read(buffer, (int)0, 14050); for (int i = 0; i < buffer.Length; i++) { Console.Write(buffer[i].ToString()); } //Download File Operation file.DownloadToFile(@"D:\TestFile.pptx", FileMode.Create); }
/// <summary> /// Test some of the file storage operations. /// </summary> public async Task RunFileStorageOperationsAsync() { // These are used in the finally block to clean up the objects created during the demo. CloudFile cloudFile = null; CloudFileDirectory fileDirectory = null; string destFile = null; CloudBlob targetBlob = null; CloudFileShare cloudFileShare = null; string downloadFolder = null; CloudBlobContainer cloudBlobContainer = null; try { //***** Setup *****// Console.WriteLine("Getting reference to the storage account."); // 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 = Common.CreateStorageAccountFromConnectionString(CloudConfigurationManager.GetSetting("StorageConnectionString")); Console.WriteLine("Instantiating file client."); // Create a file client for interacting with the file service. CloudFileClient cloudFileClient = storageAccount.CreateCloudFileClient(); // Create the share name -- use a guid in the name so it's unique. // This will also be used as the container name for blob storage when copying the file to blob storage. string shareName = "demotest-" + System.Guid.NewGuid().ToString(); // Name of folder to put the files in string sourceFolder = "testfolder"; // Name of file to upload and download string testFile = "HelloWorld.png"; // Folder where the HelloWorld.png file resides string localFolder = @".\"; // It won't let you download in the same folder as the exe file, // so use a temporary folder with the same name as the share. downloadFolder = Path.Combine(Path.GetTempPath(), shareName); //***** Create a file share *****// // Create the share if it doesn't already exist. Console.WriteLine("Creating share with name {0}", shareName); cloudFileShare = cloudFileClient.GetShareReference(shareName); try { await cloudFileShare.CreateIfNotExistsAsync(); Console.WriteLine(" Share created successfully."); } catch (StorageException exStorage) { Common.WriteException(exStorage); Console.WriteLine("Please make sure your storage account has storage file endpoint enabled and specified correctly in the app.config - then restart the sample."); Console.WriteLine("Press any key to exit"); Console.ReadLine(); throw; } catch (Exception ex) { Console.WriteLine(" Exception thrown creating share."); Common.WriteException(ex); throw; } //***** Create a directory on the file share *****// // Create a directory on the share. Console.WriteLine("Creating directory named {0}", sourceFolder); // First, get a reference to the root directory, because that's where you're going to put the new directory. CloudFileDirectory rootDirectory = cloudFileShare.GetRootDirectoryReference(); // Set a reference to the file directory. // If the source folder is null, then use the root folder. // If the source folder is specified, then get a reference to it. if (string.IsNullOrWhiteSpace(sourceFolder)) { // There is no folder specified, so return a reference to the root directory. fileDirectory = rootDirectory; Console.WriteLine(" Using root directory."); } else { // There was a folder specified, so return a reference to that folder. fileDirectory = rootDirectory.GetDirectoryReference(sourceFolder); await fileDirectory.CreateIfNotExistsAsync(); Console.WriteLine(" Directory created successfully."); } //***** Upload a file to the file share *****// // Set a reference to the file. cloudFile = fileDirectory.GetFileReference(testFile); // Upload a file to the share. Console.WriteLine("Uploading file {0} to share", testFile); // Set up the name and path of the local file. string sourceFile = Path.Combine(localFolder, testFile); if (File.Exists(sourceFile)) { // Upload from the local file to the file share in azure. await cloudFile.UploadFromFileAsync(sourceFile); Console.WriteLine(" Successfully uploaded file to share."); } else { Console.WriteLine("File not found, so not uploaded."); } //***** Get list of all files/directories on the file share*****// // List all files/directories under the root directory. Console.WriteLine("Getting list of all files/directories under the root directory of the share."); IEnumerable <IListFileItem> fileList = cloudFileShare.GetRootDirectoryReference().ListFilesAndDirectories(); // Print all files/directories listed above. foreach (IListFileItem listItem in fileList) { // listItem type will be CloudFile or CloudFileDirectory. Console.WriteLine(" - {0} (type: {1})", listItem.Uri, listItem.GetType()); } Console.WriteLine("Getting list of all files/directories in the file directory on the share."); // Now get the list of all files/directories in your directory. // Ordinarily, you'd write something recursive to do this for all directories and subdirectories. fileList = fileDirectory.ListFilesAndDirectories(); // Print all files/directories in the folder. foreach (IListFileItem listItem in fileList) { // listItem type will be CloudFile or CloudFileDirectory. Console.WriteLine(" - {0} (type: {1})", listItem.Uri, listItem.GetType()); } //***** Download a file from the file share *****// // Download the file to the downloadFolder in the temp directory. // Check and if the directory doesn't exist (which it shouldn't), create it. Console.WriteLine("Downloading file from share to local temp folder {0}.", downloadFolder); if (!Directory.Exists(downloadFolder)) { Directory.CreateDirectory(downloadFolder); } // Download the file. await cloudFile.DownloadToFileAsync(Path.Combine(downloadFolder, testFile), FileMode.OpenOrCreate); Console.WriteLine(" Successfully downloaded file from share to local temp folder."); //***** Copy a file from the file share to blob storage, then abort the copy *****// // Copies can sometimes complete before there's a chance to abort. // If that happens with the file you're testing with, try copying the file // to a storage account in a different region. If it still finishes too fast, // try using a bigger file and copying it to a different region. That will almost always // take long enough to give you time to abort the copy. // If you want to change the file you're testing the Copy with without changing the value for the // rest of the sample code, upload the file to the share, then assign the name of the file // to the testFile variable right here before calling GetFileReference. // Then it will use the new file for the copy and abort but the rest of the code // will still use the original file. CloudFile cloudFileCopy = fileDirectory.GetFileReference(testFile); // Upload a file to the share. Console.WriteLine("Uploading file {0} to share", testFile); // Set up the name and path of the local file. string sourceFileCopy = Path.Combine(localFolder, testFile); await cloudFileCopy.UploadFromFileAsync(sourceFileCopy); Console.WriteLine(" Successfully uploaded file to share."); // Copy the file to blob storage. Console.WriteLine("Copying file to blob storage. Container name = {0}", shareName); // First get a reference to the blob. CloudBlobClient cloudBlobClient = storageAccount.CreateCloudBlobClient(); // Get a reference to the blob container and create it if it doesn't already exist. cloudBlobContainer = cloudBlobClient.GetContainerReference(shareName); cloudBlobContainer.CreateIfNotExists(); // Get a blob reference to the target blob. targetBlob = cloudBlobContainer.GetBlobReference(testFile); string copyId = string.Empty; // Get a reference to the file to be copied. cloudFile = fileDirectory.GetFileReference(testFile); // Create a SAS for the file that's valid for 24 hours. // Note that when you are copying a file to a blob, or a blob to a file, you must use a SAS // to authenticate access to the source object, even if you are copying within the same // storage account. string fileSas = cloudFile.GetSharedAccessSignature(new SharedAccessFilePolicy() { // Only read permissions are required for the source file. Permissions = SharedAccessFilePermissions.Read, SharedAccessExpiryTime = DateTime.UtcNow.AddHours(24) }); // Construct the URI to the source file, including the SAS token. Uri fileSasUri = new Uri(cloudFile.StorageUri.PrimaryUri.ToString() + fileSas); // Start the copy of the file to the blob. copyId = await targetBlob.StartCopyAsync(fileSasUri); Console.WriteLine(" File copy started successfully. copyID = {0}", copyId); /* // Abort the copy of the file to blob storage. * // Note that you call Abort on the target object, i.e. the blob, not the file. * // If you were copying from one file to another on the file share, the target object would be a file. * Console.WriteLine("Check the copy status. If pending, cancel the copy operation"); * * // Print out the copy state information. * targetBlob.FetchAttributes(); * Console.WriteLine(" targetBlob.copystate.CopyId = {0}", targetBlob.CopyState.CopyId); * Console.WriteLine(" targetBlob.copystate.Status = {0}", targetBlob.CopyState.Status); * * // Do the actual abort copy. * // This only works if the copy is still pending or ongoing. * if (targetBlob.CopyState.Status == CopyStatus.Pending) * { * Console.WriteLine(" Status is Pending; cancelling the copy operation."); * // Call to stop the copy, passing in the copyId of the operation. * // This won't work if it has already finished copying. * await targetBlob.AbortCopyAsync(copyId); * Console.WriteLine(" Cancelling the copy succeeded."); * } * else * { * // If this happens, try a larger file. * Console.WriteLine(" Cancellation of copy not performed; copy has already finished."); * } */ // Now clean up after yourself. Console.WriteLine("Deleting the files from the file share."); // Delete the files because cloudFile is a different file in the range sample. cloudFile = fileDirectory.GetFileReference(testFile); cloudFile.DeleteIfExists(); Console.WriteLine("Setting up files to test WriteRange and ListRanges."); //***** Write 2 ranges to a file, then list the ranges *****// // This is the code for trying out writing data to a range in a file, // and then listing those ranges. // Get a reference to a file and write a range of data to it . // Then write another range to it. // Then list the ranges. // Start at the very beginning of the file. long startOffset = 0; // Set the destination file name -- this is the file on the file share that you're writing to. destFile = "rangeops.txt"; cloudFile = fileDirectory.GetFileReference(destFile); // Create a string with 512 a's in it. This will be used to write the range. int testStreamLen = 512; string textToStream = string.Empty; textToStream = textToStream.PadRight(testStreamLen, 'a'); // Name to be used for the file when downloading it so you can inspect it locally string downloadFile; using (MemoryStream ms = new MemoryStream(Encoding.Default.GetBytes(textToStream))) { // Max size of the output file; have to specify this when you create the file // I picked this number arbitrarily. long maxFileSize = 65536; Console.WriteLine("Write first range."); // Set the stream back to the beginning, in case it's been read at all. ms.Position = 0; // If the file doesn't exist, create it. // The maximum file size is passed in. It has to be big enough to hold // all the data you're going to write, so don't set it to 256k and try to write two 256-k blocks to it. if (!cloudFile.Exists()) { Console.WriteLine("File doesn't exist, create empty file to write ranges to."); // Create a file with a maximum file size of 64k. await cloudFile.CreateAsync(maxFileSize); Console.WriteLine(" Empty file created successfully."); } // Write the stream to the file starting at startOffset for the length of the stream. Console.WriteLine("Writing range to file."); await cloudFile.WriteRangeAsync(ms, startOffset, null); // Download the file to your temp directory so you can inspect it locally. downloadFile = Path.Combine(downloadFolder, "__testrange.txt"); Console.WriteLine("Downloading file to examine."); await cloudFile.DownloadToFileAsync(downloadFile, FileMode.OpenOrCreate); Console.WriteLine(" Successfully downloaded file with ranges in it to examine."); } // Now add the second range, but don't make it adjacent to the first one, or it will show only // one range, with the two combined. Put it like 1000 spaces away. When you get the range back, it will // start at the position at the 512-multiple border prior or equal to the beginning of the data written, // and it will end at the 512-multliple border after the actual end of the data. //For example, if you write to 2000-3000, the range will be the 512-multiple prior to 2000, which is // position 1536, or offset 1535 (because it's 0-based). // And the right offset of the range will be the 512-multiple after 3000, which is position 3072, // or offset 3071 (because it's 0-based). Console.WriteLine("Getting ready to write second range to file."); startOffset += testStreamLen + 1000; //randomly selected number // Create a string with 512 b's in it. This will be used to write the range. textToStream = string.Empty; textToStream = textToStream.PadRight(testStreamLen, 'b'); using (MemoryStream ms = new MemoryStream(Encoding.Default.GetBytes(textToStream))) { ms.Position = 0; // Write the stream to the file starting at startOffset for the length of the stream. Console.WriteLine("Write second range to file."); await cloudFile.WriteRangeAsync(ms, startOffset, null); Console.WriteLine(" Successful writing second range to file."); // Download the file to your temp directory so you can examine it. downloadFile = Path.Combine(downloadFolder, "__testrange2.txt"); Console.WriteLine("Downloading file with two ranges in it to examine."); await cloudFile.DownloadToFileAsync(downloadFile, FileMode.OpenOrCreate); Console.WriteLine(" Successfully downloaded file to examine."); } // Query and view the list of ranges. Console.WriteLine("Call to get the list of ranges."); IEnumerable <FileRange> listOfRanges = await cloudFile.ListRangesAsync(); Console.WriteLine(" Successfully retrieved list of ranges."); foreach (FileRange fileRange in listOfRanges) { Console.WriteLine(" --> filerange startOffset = {0}, endOffset = {1}", fileRange.StartOffset, fileRange.EndOffset); } //***** Clean up *****// } catch (Exception ex) { Console.WriteLine(" Exception thrown. Message = {0}{1} Strack Trace = {2}", ex.Message, Environment.NewLine, ex.StackTrace); } finally { //Clean up after you're done. Console.WriteLine("Removing all files, folders, shares, blobs, and containers created in this demo."); // ****NOTE: You can just delete the file share, and everything will be removed. // This samples deletes everything off of the file share first for the purpose of // showing you how to delete specific files and directories. // Delete the file with the ranges in it. destFile = "rangeops.txt"; cloudFile = fileDirectory.GetFileReference(destFile); await cloudFile.DeleteIfExistsAsync(); Console.WriteLine("Deleting the directory on the file share."); // Delete the directory. bool success = await fileDirectory.DeleteIfExistsAsync(); if (success) { Console.WriteLine(" Directory on the file share deleted successfully."); } else { Console.WriteLine(" Directory on the file share NOT deleted successfully; may not exist."); } Console.WriteLine("Deleting the file share."); // Delete the share. await cloudFileShare.DeleteAsync(); Console.WriteLine(" Deleted the file share successfully."); Console.WriteLine("Deleting the temporary download directory and the file in it."); // Delete the download folder and its contents. Directory.Delete(downloadFolder, true); Console.WriteLine(" Successfully deleted the temporary download directory."); Console.WriteLine("Deleting the container and blob used in the Copy/Abort test."); await targetBlob.DeleteIfExistsAsync(); await cloudBlobContainer.DeleteIfExistsAsync(); Console.WriteLine(" Successfully deleted the blob and its container."); } }
/// <summary> /// Delete the file async. /// </summary> /// <param name="file">The cloud file to delete.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>The async task.</returns> public async Task <bool> DeleteFileAsync(CloudFile file, CancellationToken cancellationToken) { return(await file.DeleteIfExistsAsync(cancellationToken)); }
/// <summary> /// Delete the file async. /// </summary> /// <param name="file">The cloud file to delete.</param> /// <returns>The async task.</returns> public async Task <bool> DeleteFileAsync(CloudFile file) { return(await file.DeleteIfExistsAsync()); }
public static bool DeleteIfExists(this CloudFile file, AccessCondition accessCondition = null, FileRequestOptions options = null, OperationContext operationContext = null) { return(file.DeleteIfExistsAsync(accessCondition, options, operationContext).GetAwaiter().GetResult()); }
public async Task DeleteAsync(Entry entry, Image image, ImageType type) { CloudFile imageFile = await GetFileAsync(entry, image, type); await imageFile.DeleteIfExistsAsync(); }
public async Task <bool> DeleteFile(string name) { CloudFile originalFile = baseDir.GetFileReference(name); return(await originalFile.DeleteIfExistsAsync()); }