图片已保存损坏的异步方式

Question

Why? when i save 2 images, the first saved corrupted and the second not saved at all

i want to save file without stuck the client(Task.Run) and without stuck the server(async await)

Task.Run(async () => {    
            foreach (var item in Images) 
            {
                // item.File is IFormFile array
                await SaveFile(item.FileSavePath, item.File);
            }
});

   public static async Task SaveFile(string filePath, IFormFile file)
        {
            string folderPath = Path.GetDirectoryName(filePath);
            if (!Directory.Exists(folderPath))
                Directory.CreateDirectory(folderPath);

            using (var fileStream = new FileStream(filePath, FileMode.Create))
            {
                await file.CopyToAsync(fileStream);
            }
        }

Answer 1

If the Task.Run is not awaited, then the action will almost assuredly return before the actual SaveFile tasks have finished. When the action goes out of scope, it takes all its scoped variables with it, including your IFormFile instances that were bound from the post body. This will cause the write to be prematurely cancelled, leaving you with a corrupted file (since the stream is destroyed mid-write). An exception will be raised, but because you're running inside a new thread, it won't bubble up through the request pipeline, and is effectively swallowed.

Long and short, await your call to Task.Run . However, once you do that, then there's effectively no point in using Task.Run here. So, you're better off just getting rid of it entirely. Instead, just fire off all the tasks and then await Task.WhenAll :

var tasks = new List<Task>();
foreach (var item in Images) 
{
    // item.File is IFormFile array
    tasks.Add(SaveFile(item.FileSavePath, item.File));
}
await Task.WhenAll(tasks);

Tasks return hot, or already started. As such, awaiting each item save in the foreach would result in the tasks being processed in serial. Just saving them to a list, causes them all to be started and run essentially in parallel. Then, you simply await the completion of all tasks in the lists to keep the action from returning until the work is finished.