public void InvalidArgs_Throws(bool useAsync) { using (FileStream fs = new FileStream(GetTestFilePath(), FileMode.Create, FileAccess.ReadWrite, FileShare.None, 0x100, useAsync)) { Assert.Throws<ArgumentNullException>("destination", () => { fs.CopyToAsync(null); }); Assert.Throws<ArgumentOutOfRangeException>("bufferSize", () => { fs.CopyToAsync(new MemoryStream(), 0); }); Assert.Throws<NotSupportedException>(() => { fs.CopyToAsync(new MemoryStream(new byte[1], writable: false)); }); fs.Dispose(); Assert.Throws<ObjectDisposedException>(() => { fs.CopyToAsync(new MemoryStream()); }); } using (FileStream fs = new FileStream(GetTestFilePath(), FileMode.Create, FileAccess.ReadWrite, FileShare.None, 0x100, useAsync)) { fs.SafeFileHandle.Dispose(); Assert.Throws<ObjectDisposedException>(() => { fs.CopyToAsync(new MemoryStream()); }); } using (FileStream fs = new FileStream(GetTestFilePath(), FileMode.Create, FileAccess.Write)) { Assert.Throws<NotSupportedException>(() => { fs.CopyToAsync(new MemoryStream()); }); } using (FileStream src = new FileStream(GetTestFilePath(), FileMode.Create, FileAccess.ReadWrite, FileShare.None, 0x100, useAsync)) using (FileStream dst = new FileStream(GetTestFilePath(), FileMode.Create, FileAccess.ReadWrite, FileShare.None, 0x100, useAsync)) { dst.Dispose(); Assert.Throws<ObjectDisposedException>(() => { src.CopyToAsync(dst); }); } }
public async Task AlreadyCanceled_ReturnsCanceledTask(bool useAsync) { using (FileStream fs = new FileStream(GetTestFilePath(), FileMode.Create, FileAccess.ReadWrite, FileShare.None, 0x100, useAsync)) { await Assert.ThrowsAnyAsync<OperationCanceledException>(() => fs.CopyToAsync(fs, 0x1000, new CancellationToken(canceled: true))); } }
public async Task <IActionResult> ExportExcelAsync() { string sWebRootFolder = _hostingEnvironment.WebRootPath; var memory = new MemoryStream(); using (var fs = new FileStream(Path.Combine(sWebRootFolder, _fileName), FileMode.Create, FileAccess.Write)) { IWorkbook workbook; workbook = new XSSFWorkbook(); ISheet excelSheet = workbook.CreateSheet(_table); IRow row = excelSheet.CreateRow(0); for (int i = 0; i < _titles.Length; i++) { row.CreateCell(i).SetCellValue(_titles[i]); } int count = 1; for (int i = 0; i < _listData.Count; i++) { row = excelSheet.CreateRow(count); var list = _listData[i]; for (int j = 0; j < _titles.Length; j++) { row.CreateCell(j).SetCellValue(list[j]); } count++; } workbook.Write(fs); } using (var stream = new FileStream(Path.Combine(sWebRootFolder, _fileName), FileMode.Open)) { await stream.CopyToAsync(memory); } memory.Position = 0; return(File(memory, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", _fileName)); }
async public Task <ActionResult> DownloadJobFile(int id, string token) { if (!_customAuthService.CheckToken(token)) { return(Unauthorized()); } JobFile file = _jobService.GetFile(id); if (file == null) { throw new AppException("File not found in database."); } string fileName = file.Name; string filePath = file.Path; var provider = new FileExtensionContentTypeProvider(); string contentType; if (!provider.TryGetContentType(fileName, out contentType)) { contentType = "application/octet-stream"; } string fullPath = _fileService.getFullPath(filePath); var memory = new MemoryStream(); using (var stream = new FileStream(fullPath, FileMode.Open)) { await stream.CopyToAsync(memory); } memory.Position = 0; return(File(memory, contentType)); }
/// <summary> /// Fetches an image and returns the size /// </summary> /// <param name="imageUri">image to fetch</param> /// <returns>task that returns the size of the image</returns> private static async Task <Size> GetSizeOfImage(Uri imageUri) { // get the image from the internets if (imageUri.Scheme == Uri.UriSchemeHttp || imageUri.Scheme == Uri.UriSchemeHttps) { using (var client = new HttpClient()) { using (var responseMessage = await client.GetAsync(imageUri)) { responseMessage.EnsureSuccessStatusCode(); using (Stream responseStream = await responseMessage.Content.ReadAsStreamAsync()) { var contentType = responseMessage.Content.Headers.ContentType.ToString(); Assert.IsTrue(contentType.StartsWith("image", true, System.Globalization.CultureInfo.InvariantCulture)); return(GetSizeOfImage(responseStream)); } } } } // get the image from the local disk else if (imageUri.Scheme == Uri.UriSchemeFile) { using (MemoryStream imageMemoryStream = new MemoryStream()) using (FileStream imageFileStream = new FileStream(imageUri.LocalPath, FileMode.Open, FileAccess.Read)) { await imageFileStream.CopyToAsync(imageMemoryStream); return(GetSizeOfImage(imageMemoryStream)); } } // not supported else { throw new NotImplementedException("only http, https, and file URIs are supported"); } }
public async Task <IActionResult> Download(string id) { string filePath = string.Empty; string type = string.Empty; string _contentType = string.Empty; try { if (responseData.Count > 0) { foreach (var record in responseData) { if (record.Id.ToString() == id) { filePath = record.FilePath; } } } type = Path.GetExtension(filePath); _contentType = string.Empty; var memory = new MemoryStream(); using (var stream = new FileStream(filePath, FileMode.Open)) { await stream.CopyToAsync(memory); } memory.Position = 0; // string fileName = Path.GetFileName(filePath); _contentType = "application/pmml"; return(File(memory, _contentType, fileName)); } catch (Exception ex) { return(BadRequest(ex.Message + "filePath :" + filePath)); } }
[HttpGet("Download")] //api/Populations/Download public async Task <IActionResult> OnPostExport() { string sWebRootFolder = _hostingEnvironment.WebRootPath; string sFileName = @"excels/demo.xlsx"; FileInfo file = new FileInfo(Path.Combine(sWebRootFolder, sFileName)); var memory = new MemoryStream(); using (var fs = new FileStream(Path.Combine(sWebRootFolder, sFileName), FileMode.Create, FileAccess.Write)) { IWorkbook workbook = new XSSFWorkbook(); ISheet excelSheet = workbook.CreateSheet("popn"); IRow rowLabels = excelSheet.CreateRow(0); var populations = _context.Populations.Include(popn => popn.Year).GroupBy(popn => popn.YearID).Select(popn => popn.First()); rowLabels.CreateCell(1).SetCellValue("PH POPN"); var i = 1; foreach (var population in populations) { IRow row = excelSheet.CreateRow(i); row.CreateCell(0).SetCellValue(Int32.Parse(population.Year.Name)); row.CreateCell(1).SetCellValue(population.Populations); i++; } workbook.Write(fs); } using (var stream = new FileStream(Path.Combine(sWebRootFolder, sFileName), FileMode.Open)) { await stream.CopyToAsync(memory); } memory.Position = 0; var newFileName = "POPN_" + DateTime.Now.ToString("MM-dd-yyyy_hh:mm_tt") + ".xlsx"; return(File(memory, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", newFileName)); }
public async Task <IActionResult> OnGetDownloadAsync(int id) { var username = HttpContext.Session.GetString("_username"); var usertype = HttpContext.Session.GetString("_usertype"); var access = new Access(username, "Student"); if (access.IsLogin()) { if (access.IsAuthorize(usertype)) { var announcement = await _context.Announcement .FirstOrDefaultAsync(a => a.AnnouncementId == id); var filePath = announcement.AttachmentFolder + announcement.AttachmentFile; var path = Path.Combine(Directory.GetCurrentDirectory(), announcement.AttachmentFolder.Substring(1, announcement.AttachmentFolder.Length - 2), announcement.AttachmentFile); var memory = new MemoryStream(); using (var stream = new FileStream(path, FileMode.Open)) { await stream.CopyToAsync(memory); } memory.Position = 0; return(File(memory, FileService.GetContentType(path), Path.GetFileName(path))); } else { ErrorMessage = "Access Denied"; return(RedirectToPage($"/{usertype}/Index")); } } else { ErrorMessage = "Login Required"; return(RedirectToPage("/Account/Login")); } }
protected async Task <string> MergePartitionsAsync() { if (_options.Override) { if (File.Exists(_fullPath)) { File.Delete(_fullPath); } } _fullPath = PrepareFileName(); using (var file = new FileStream(_fullPath, FileMode.Create, FileAccess.Write)) { foreach (var p in _status.Partitions) { if (File.Exists(p.Path)) { using (var partitionFile = new FileStream(p.Path, FileMode.Open, FileAccess.Read)) { await partitionFile.CopyToAsync(file); } File.Delete(p.Path); } } } var saved = LookingPartitionFile(); if (saved.model != null) { SaveModelFactory.RemoveSaveModel(saved.fileName); } _completed = true; return(_fullPath); }
public async Task <IHttpActionResult> SaveImageItem(string storeId, string themeId, string folderName) { if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } var provider = new MultipartFileStreamProvider(_pathForMultipart); await Request.Content.ReadAsMultipartAsync(provider); var loadItemInfo = new LoadItemInfo(); foreach (var file in provider.FileData) { var fileInfo = new FileInfo(file.LocalFileName); using (FileStream stream = fileInfo.OpenRead()) { var fileName = file.Headers.ContentDisposition.FileName.Replace("\"", string.Empty); var filePath = string.Format("{0}{1}", _pathForFiles, fileName); using (var f = File.Create(filePath)) { await stream.CopyToAsync(f); } loadItemInfo.Name = fileName; loadItemInfo.ContentType = file.Headers.ContentType.MediaType; if (ContentTypeUtility.IsImageContentType(loadItemInfo.ContentType)) { loadItemInfo.Content = ContentTypeUtility. ConvertImageToBase64String(File.ReadAllBytes(filePath), file.Headers.ContentType.MediaType); } } } return(this.Ok(loadItemInfo)); }
public async Task <IActionResult> Decipher(IFormFile file, [FromForm] Key key) { CreateDirectory(); var ExtensionFile = ""; ExtensionFile = Path.GetExtension(file.FileName); switch (ExtensionFile) { case ".zz": ZigZag.Decifrar(file, key.levels); break; case ".csr": Cesar.Decifrar(file, key.word); break; case ".rt": Route.DecifradoEspiral(file, key.columns, key.rows); break; default: return(StatusCode(StatusCodes.Status500InternalServerError)); break; } var path = Environment.CurrentDirectory + "\\temp\\" + Path.GetFileNameWithoutExtension(file.FileName) + ".txt"; var Memory = new MemoryStream(); using (var Stream = new FileStream(path, FileMode.Open)) { await Stream.CopyToAsync(Memory); } Memory.Position = 0; var extensionFile = Path.GetExtension(path).ToLowerInvariant(); DeleteDirectoy(); return(File(Memory, GetMimeTypes()[extensionFile], Path.GetFileName(path))); }
// when we make code async.... // the method has to have the "async" modifier // the method needs to return a Task (for void-return) or // a Task<Something> if we wanted to return Something. // the method should say Async at the end of its name (for self-documenting purposes) // when we call async methods in our own methods, we need to "await" the tasks they // give us. private static async Task <List <Person> > DeserializeXMLFromFileAsync(string fileName) { var serializer = new XmlSerializer(typeof(List <Person>)); // in addition to those XmlBlahBlah attributes, we can also customize // the format on the serializer object itself. // we're going to use "using statement", not to be confused // with "using directive" at the top of the file. // in place of boilerplate code with IDisposable "try finally dispose" using (var memoryStream = new MemoryStream()) { using (var fileStream = new FileStream(fileName, FileMode.Open)) { // copy the filestream into the memorystream //Task copying = fileStream.CopyToAsync(memoryStream); //await copying; await fileStream.CopyToAsync(memoryStream); // when the method executing reaches an await statement, // it allows other code to run in the meantime. // the objects you're using need to support async, or you aren't // able to use it // XmlSerializer.DeserializeAsync doesn't exist, or else, // we wouldn't need the memoryStream } // using statement automatically disposes the resource when we exit it // reset "cursor" of stream to beginning to read its contents memoryStream.Position = 0; return((List <Person>)serializer.Deserialize(memoryStream)); // should be try-catching throughout this method } }
public static async Task <TaskResult> EncryptFile(string file, string OutPath = "") { string output = file; if (OutPath != "") { output = OutPath; } try { output = Path.Combine(Path.GetDirectoryName(output), StringCipher.GenerateName(Path.GetFileName(output))); var aes = new AesManaged(); aes.BlockSize = aes.LegalBlockSizes[0].MaxSize; aes.KeySize = aes.LegalKeySizes[0].MaxSize; var salt = await GetBytes(SaltKey); var key = new Rfc2898DeriveBytes(SKey, salt, Iterations); aes.Key = key.GetBytes(aes.KeySize / 8); aes.IV = key.GetBytes(aes.BlockSize / 8); aes.Mode = CipherMode.CBC; ICryptoTransform transform = aes.CreateEncryptor(aes.Key, aes.IV); using (var dest = new FileStream((output), FileMode.CreateNew, FileAccess.Write, FileShare.None)) { using (var cryptoStream = new CryptoStream(dest, transform, CryptoStreamMode.Write)) { using (var source = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read)) { await source.CopyToAsync(cryptoStream); } } } File.Delete(file); return(TaskResult.Done); } catch (Exception e) { Debug.WriteLine("EncryptFileMethod Error " + e.Message); return(TaskResult.Failed); } }
public async Task <IActionResult> Download(string filename) { if (filename == null) { return(Content("filename not present")); } var filePath = Path.Combine(Directory.GetCurrentDirectory(), memberPicDirectory, filename); if (!System.IO.File.Exists(filePath)) { return(NotFound("File Not Found")); } var memory = new MemoryStream(); using (var stream = new FileStream(filePath, FileMode.Open)) { await stream.CopyToAsync(memory); } memory.Position = 0; return(File(memory, GetContentType(filePath), Path.GetFileName(filePath))); }
internal async Task <HttpResponseMessage> ComposeFileResponse(string path) { var stream = new MemoryStream(); using (var fileStream = new FileStream(path, FileMode.Open)) { await fileStream.CopyToAsync(stream); } stream.Position = 0; var result = new HttpResponseMessage(HttpStatusCode.OK) { Content = new ByteArrayContent(stream.GetBuffer()) }; result.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment") { FileName = Path.GetFileName(path) }; result.Content.Headers.ContentType = new MediaTypeHeaderValue("application/pdf"); return(result); }
public async Task <IActionResult> Descarga(int idDocumento) { try { Documento documento = DocumentosAdjuntosDAO.getDocumentoById(idDocumento); String directorioTemporal = @"\SIPRO\archivos\documentos\"; String filePath = directorioTemporal + @"\" + documento.idTipoObjeto + @"\" + documento.idObjeto + @"\" + documento.nombre; var memory = new MemoryStream(); using (var stream = new FileStream(filePath, FileMode.Open)) { await stream.CopyToAsync(memory); } memory.Position = 0; return(File(memory, GetContentType(filePath), Path.GetFileName(filePath))); } catch (Exception e) { CLogger.write("3", "DocumentoAdjuntoController.class", e); return(BadRequest(500)); } }
public async Task <object> getfile(int?questionid) { var question = _context.Questions.Include(i => i.Subject).Where(w => w.ID == questionid).FirstOrDefault(); if (question != null) { //var filePath = Directory.GetCurrentDirectory() + "\\wwwroot\\questions\\" + question.ID + "\\"; var filename = question.FileName; if (System.IO.File.Exists(filename)) { var memory = new MemoryStream(); using (var stream = new FileStream(filename, FileMode.Open)) { await stream.CopyToAsync(memory); } memory.Position = 0; var mimeType = "audio/mp3"; return(File(memory, mimeType, Path.GetFileName(filename))); } } return(CreatedAtAction(nameof(getfile), new { result = ResultCode.DataHasNotFound, message = ResultMessage.DataHasNotFound })); }
public async Task <IActionResult> Download(string filename) { try { if (filename == null) { return(Content("El archivo no existe")); } var path = Path.Combine(Directory.GetCurrentDirectory(), "facturas", filename); var memory = new MemoryStream(); using (var stream = new FileStream(path, FileMode.Open)) { await stream.CopyToAsync(memory); } memory.Position = 0; return(File(memory, GetContentType(path), Path.GetFileName(path))); } catch (Exception ex) { return(StatusCode(500, ex.Message.ToString())); } }
public async Task <IActionResult> Download(string filename) { if (filename == null) { return(Content("filename not present")); } var path = Path.Combine( Directory.GetCurrentDirectory(), "wwwroot", filename); var memory = new MemoryStream(); using (var stream = new FileStream(path, FileMode.Open)) { await stream.CopyToAsync(memory); } memory.Position = 0; //var fileExtensionContentTypeProvider = new FileExtensionContentTypeProvider(); //string contentType = ""; fileExtensionContentTypeProvider.TryGetContentType(path, out contentType); return(File(memory, GetContentType(path), Path.GetFileName(path))); }
public async Task <IActionResult> Download(int?id) { if (id == null) { return(Content("Arquivo Invalido")); } Arquivo arquivo = await _context.Arquivo. SingleOrDefaultAsync(a => a.Id == id); var path = Path.Combine( Directory.GetCurrentDirectory(), "wwwroot/files/", arquivo.Endereco); var memory = new MemoryStream(); using (var stream = new FileStream(path, FileMode.Open)) { await stream.CopyToAsync(memory); } memory.Position = 0; return(File(memory, arquivo.Tipo, arquivo.Nome)); }
public async Task <IActionResult> GetAttachcment(int id) { var attachment = _chatContext.Attachments.Find(id); if (attachment == null) { return(NotFound()); } var file = hostingEnvironment.WebRootPath + "\\Attachments\\" + attachment.FileId; if (!System.IO.File.Exists(file)) { return(NotFound()); } var memory = new MemoryStream(); using (var stream = new FileStream(file, FileMode.Open)) { await stream.CopyToAsync(memory); } memory.Position = 0; return(File(memory, attachment.ContentType, attachment.FileName)); }
// GET: Documents public async Task <IActionResult> Download(int id) { var document = await _documentService.Get(id); if (document == null) { return(Content("Fil finnes ikke")); } if (document.OrganizationNumber == HttpContext.Session.GetString("OrganizationNumber")) { string path = _applicationSettings.FilePath + "\\" + document.FileName; var memory = new MemoryStream(); using (var stream = new FileStream(path, FileMode.Open)) { await stream.CopyToAsync(memory); } memory.Position = 0; return(File(memory, Helper.GetContentType(path), Path.GetFileName(path))); } return(NotFound()); }
public static async Task <MemoryStream> ReadFileAsync(string pathFile) { if (!System.IO.File.Exists(pathFile)) { return(null); } try { FileInfo file = new FileInfo(pathFile); var memory = new MemoryStream(); using (var stream = new FileStream(pathFile, FileMode.Open)) { await stream.CopyToAsync(memory); } memory.Position = 0; return(memory); } catch (Exception e) { return(null); } }
private async Task <BackgroundImage> CopyNextBackgroundToLocalCacheAsync() { if (!this._nextBackgrounds.TryDequeue(out BackgroundImage srcImg)) { return(null); // failed, queue empty for some reason } string src = srcImg.OriginalSourceFile; string dst = this._localCopyFullPath; this._logger.LogInformation($"copy '{src}' ({srcImg.Width}x{srcImg.Height}) to '{dst}'"); const int bufSize = 4096; const FileOptions opt = FileOptions.Asynchronous | FileOptions.SequentialScan; using (var sourceStream = new FileStream(src, FileMode.Open, FileAccess.Read, FileShare.Read, bufSize, opt)) using (var destinationStream = new FileStream(dst, FileMode.Create, FileAccess.Write, FileShare.None, bufSize, opt)) { await sourceStream.CopyToAsync(destinationStream); await destinationStream.FlushAsync(); } srcImg.RelativeWebRootLocation = this._relativePath; return(srcImg); }
public static async Task CopyFileAsync(string sourceFile, string destinationFile, CancellationToken cancellationToken) { var fileOptions = FileOptions.Asynchronous | FileOptions.SequentialScan; var bufferSize = 81920; try { File.Delete(destinationFile); } catch (Exception e) { Console.WriteLine("Warning: " + destinationFile + " could not be deleted: " + e.ToString()); } using (var sourceStream = new FileStream(sourceFile, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize, fileOptions)) using (var destinationStream = new FileStream(destinationFile, FileMode.CreateNew, FileAccess.Write, FileShare.None, bufferSize, fileOptions)) await sourceStream.CopyToAsync(destinationStream, bufferSize, cancellationToken) .ConfigureAwait(continueOnCapturedContext: false); }
public async Task NamedPipeViaFileStream_CancellationRequested_OperationCanceled() { string name = Guid.NewGuid().ToString("N"); using (var server = new NamedPipeServerStream(name, PipeDirection.Out, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous)) { Task serverTask = server.WaitForConnectionAsync(); Assert.True(WaitNamedPipeW(@"\\.\pipe\" + name, -1)); using (SafeFileHandle clientHandle = CreateFileW(@"\\.\pipe\" + name, GENERIC_READ, FileShare.None, IntPtr.Zero, FileMode.Open, (int)PipeOptions.Asynchronous, IntPtr.Zero)) using (var client = new FileStream(clientHandle, FileAccess.Read, bufferSize: 3, isAsync: true)) { await serverTask; var cts = new CancellationTokenSource(); Task clientTask = client.CopyToAsync(new MemoryStream(), 0x1000, cts.Token); Assert.False(clientTask.IsCompleted); cts.Cancel(); await Assert.ThrowsAsync <OperationCanceledException>(() => clientTask); } } }
public async Task <IActionResult> Download(Guid id) { if (id == null || id == Guid.Empty) { return(NotFound()); } var file = _context.Find <CSVFile>(id); if (file == null || string.IsNullOrEmpty(file.Path) || string.IsNullOrWhiteSpace(file.Path)) { return(NotFound()); } var stream = new MemoryStream(); using var fileStream = new FileStream(file.Path, FileMode.Open); await fileStream.CopyToAsync(stream); stream.Position = 0; return(File(stream, "text/csv")); }
public override IEnumerable <string> Save(IFormFileProp formFileProp) { string[] result = new string[1]; if (formFileProp.Name == null) { formFileProp.Name = GetFileName(formFileProp.OldPath); } string carImagePathAndName = formFileProp.NewPath + formFileProp.Name + FileExtension(formFileProp.OldPath); StreamWriter streamWriter = new StreamWriter(carImagePathAndName); if (string.IsNullOrEmpty(formFileProp.OldPath) == false) { using (FileStream source = System.IO.File.Open(formFileProp.OldPath, FileMode.Open)) { source.CopyToAsync(streamWriter.BaseStream); source.Flush(); source.Dispose(); } result[0] = formFileProp.Name + FileExtension(formFileProp.OldPath); } return(result); }
public async Task <IActionResult> Get(Guid?id) { if (id == null) { return(BadRequest()); } var songId = id; // Should be generic type. var path = GetFilePath(songId.Value); // System.Console.WriteLine(path); var memory = new MemoryStream(); await using (var stream = new FileStream(path, FileMode.Open)) { await stream.CopyToAsync(memory); } memory.Position = 0; return(File(memory, GetContentType(path), Path.GetFileName(path))); }
public async Task <IActionResult> DownloadLatest() { //if (file == null) // return Content("filename not present"); //var files = Request.Form.Files; //var date = Request.Form["date"]; var path = Path.Combine( Directory.GetCurrentDirectory(), "wwwroot", "DailyData" + DateTime.Today.ToString("yyyyMMddd") + ".txt"); var lastdate = await CreateStockPriceFile(path); var memory = new MemoryStream(); using (var stream = new FileStream(path, FileMode.Open)) { await stream.CopyToAsync(memory); } memory.Position = 0; return(File(memory, GetContentType(path), Path.GetFileName(path))); }
public async Task <IActionResult> Download(string filename) { if (filename == null) { return(Content("filename not present")); } var path = Path.Combine( Directory.GetCurrentDirectory(), "wwwroot/images", filename); var memory = new MemoryStream(); using (var stream = new FileStream(path, FileMode.Open)) { await stream.CopyToAsync(memory); } memory.Position = 0; return(File(memory, GetContentType(path), Path.GetFileName(path))); //return File(memory, GetContentType(path), Path.GetFileName(path).Split('_').Last()); }
public async Task <IActionResult> Download(string filename, string folder = "") { if (filename == null) { return(Content("filename not present")); } folder = string.IsNullOrEmpty(folder) ? Consts.BROCHURE_FOLDER_NAME : folder; var path = Path.Combine(_hostingEnvironment.WebRootPath, folder, filename); if (!System.IO.File.Exists(path)) { return(NotFound()); } var memory = new MemoryStream(); using (var stream = new FileStream(path, FileMode.Open)) { await stream.CopyToAsync(memory); } memory.Position = 0; return(File(memory, GetContentType(path), Path.GetFileName(path))); }
public async Task File_AllDataCopied( Func<string, Stream> createDestinationStream, bool useAsync, bool preRead, bool preWrite, bool exposeHandle, bool cancelable, int bufferSize, int writeSize, int numWrites) { // Create the expected data long totalLength = writeSize * numWrites; var expectedData = new byte[totalLength]; new Random(42).NextBytes(expectedData); // Write it out into the source file string srcPath = GetTestFilePath(); File.WriteAllBytes(srcPath, expectedData); string dstPath = GetTestFilePath(); using (FileStream src = new FileStream(srcPath, FileMode.Open, FileAccess.ReadWrite, FileShare.None, bufferSize, useAsync)) using (Stream dst = createDestinationStream(dstPath)) { // If configured to expose the handle, do so. This influences the stream's need to ensure the position is in sync. if (exposeHandle) { var ignored = src.SafeFileHandle; } // If configured to "preWrite", do a write before we start reading. if (preWrite) { src.Write(new byte[] { 42 }, 0, 1); dst.Write(new byte[] { 42 }, 0, 1); expectedData[0] = 42; } // If configured to "preRead", read one byte from the source prior to the CopyToAsync. // This helps test what happens when there's already data in the buffer, when the position // isn't starting at zero, etc. if (preRead) { int initialByte = src.ReadByte(); if (initialByte >= 0) { dst.WriteByte((byte)initialByte); } } // Do the copy await src.CopyToAsync(dst, writeSize, cancelable ? new CancellationTokenSource().Token : CancellationToken.None); dst.Flush(); // Make sure we're at the end of the source file Assert.Equal(src.Length, src.Position); // Verify the copied data dst.Position = 0; var result = new MemoryStream(); dst.CopyTo(result); byte[] actualData = result.ToArray(); Assert.Equal(expectedData.Length, actualData.Length); Assert.Equal<byte>(expectedData, actualData); } }
public void CopyToAsync_InvalidArgs_Throws() { using (FileStream fs = new FileStream(GetTestFilePath(), FileMode.Create)) { Assert.Throws<ArgumentNullException>("destination", () => { fs.CopyToAsync(null); }); Assert.Throws<ArgumentOutOfRangeException>("bufferSize", () => { fs.CopyToAsync(new MemoryStream(), 0); }); Assert.Throws<NotSupportedException>(() => { fs.CopyToAsync(new MemoryStream(new byte[1], writable: false)); }); fs.Dispose(); Assert.Throws<ObjectDisposedException>(() => { fs.CopyToAsync(new MemoryStream()); }); } using (FileStream fs = new FileStream(GetTestFilePath(), FileMode.Create, FileAccess.Write)) { Assert.Throws<NotSupportedException>(() => { fs.CopyToAsync(new MemoryStream()); }); } }
public async Task NamedPipeViaFileStream_CancellationRequested_OperationCanceled() { string name = Guid.NewGuid().ToString("N"); using (var server = new NamedPipeServerStream(name, PipeDirection.Out, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous)) { Task serverTask = server.WaitForConnectionAsync(); Assert.True(WaitNamedPipeW(@"\\.\pipe\" + name, -1)); using (SafeFileHandle clientHandle = CreateFileW(@"\\.\pipe\" + name, GENERIC_READ, FileShare.None, IntPtr.Zero, FileMode.Open, (int)PipeOptions.Asynchronous, IntPtr.Zero)) using (var client = new FileStream(clientHandle, FileAccess.Read, bufferSize: 3, isAsync: true)) { await serverTask; var cts = new CancellationTokenSource(); Task clientTask = client.CopyToAsync(new MemoryStream(), 0x1000, cts.Token); Assert.False(clientTask.IsCompleted); cts.Cancel(); await Assert.ThrowsAsync<OperationCanceledException>(() => clientTask); } } }
public async Task NamedPipeViaFileStream_AllDataCopied(bool useAsync, int writeSize, int numWrites) { long totalLength = writeSize * numWrites; var expectedData = new byte[totalLength]; new Random(42).NextBytes(expectedData); var results = new MemoryStream(); var pipeOptions = useAsync ? PipeOptions.Asynchronous : PipeOptions.None; string name = Guid.NewGuid().ToString("N"); using (var server = new NamedPipeServerStream(name, PipeDirection.Out, 1, PipeTransmissionMode.Byte, pipeOptions)) { Task serverTask = Task.Run(async () => { await server.WaitForConnectionAsync(); for (int i = 0; i < numWrites; i++) { await server.WriteAsync(expectedData, i * writeSize, writeSize); } server.Dispose(); }); Assert.True(WaitNamedPipeW(@"\\.\pipe\" + name, -1)); using (SafeFileHandle clientHandle = CreateFileW(@"\\.\pipe\" + name, GENERIC_READ, FileShare.None, IntPtr.Zero, FileMode.Open, (int)pipeOptions, IntPtr.Zero)) using (var client = new FileStream(clientHandle, FileAccess.Read, bufferSize: 3, isAsync: useAsync)) { Task copyTask = client.CopyToAsync(results, (int)totalLength); await await Task.WhenAny(serverTask, copyTask); await copyTask; } } byte[] actualData = results.ToArray(); Assert.Equal(expectedData.Length, actualData.Length); Assert.Equal<byte>(expectedData, actualData); }
[OuterLoop] // many combinations: we test just one in inner loop and the rest outer public async Task CopyToAsyncBetweenFileStreams( bool useAsync, bool preSize, bool exposeHandle, bool cancelable, int bufferSize, int writeSize, int numWrites) { long totalLength = writeSize * numWrites; var expectedData = new byte[totalLength]; new Random(42).NextBytes(expectedData); string srcPath = GetTestFilePath(); File.WriteAllBytes(srcPath, expectedData); string dstPath = GetTestFilePath(); using (FileStream src = new FileStream(srcPath, FileMode.Open, FileAccess.Read, FileShare.None, bufferSize, useAsync)) using (FileStream dst = new FileStream(dstPath, FileMode.Create, FileAccess.Write, FileShare.None, bufferSize, useAsync)) { await src.CopyToAsync(dst, writeSize, cancelable ? new CancellationTokenSource().Token : CancellationToken.None); } byte[] actualData = File.ReadAllBytes(dstPath); Assert.Equal(expectedData.Length, actualData.Length); Assert.Equal<byte>(expectedData, actualData); }
public async Task AnonymousPipeViaFileStream_AllDataCopied(int writeSize, int numWrites) { long totalLength = writeSize * numWrites; var expectedData = new byte[totalLength]; new Random(42).NextBytes(expectedData); var results = new MemoryStream(); using (var server = new AnonymousPipeServerStream(PipeDirection.Out)) { Task serverTask = Task.Run(async () => { for (int i = 0; i < numWrites; i++) { await server.WriteAsync(expectedData, i * writeSize, writeSize); } }); using (var client = new FileStream(new SafeFileHandle(server.ClientSafePipeHandle.DangerousGetHandle(), false), FileAccess.Read, bufferSize: 3)) { Task copyTask = client.CopyToAsync(results, writeSize); await await Task.WhenAny(serverTask, copyTask); server.Dispose(); await copyTask; } } byte[] actualData = results.ToArray(); Assert.Equal(expectedData.Length, actualData.Length); Assert.Equal<byte>(expectedData, actualData); }