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);
}
