C# IFormFile.SaveAsAsync方法代码示例

        public async Task<IActionResult> Index(IFormFile photo, string query, string lat, string lng)
        {
            if (photo != null)
            {
                Notez note = new Notez
                {
                    Found = true,
                    Timestamp = DateTimeOffset.Now,
                    UserAgent = Request.Headers["User-Agent"],
                    HostAddress = Context.GetFeature<IHttpConnectionFeature>().RemoteIpAddress.ToString(),
                    LocationRaw = query,
                };

                if (!string.IsNullOrWhiteSpace(query) && (string.IsNullOrWhiteSpace(lat) || string.IsNullOrWhiteSpace(lng)))
                {
                    using (HttpClient http = new HttpClient())
                    {
                        Stream response = await http.GetStreamAsync("http://maps.googleapis.com/maps/api/geocode/xml?address=" + Uri.EscapeDataString(query));
                        XDocument xml = XDocument.Load(response);

                        if (xml.Root.Element("status")?.Value == "OK")
                        {
                            XElement location = xml.Root.Element("result")?.Element("geometry")?.Element("location");

                            lat = location?.Element("lat")?.Value;
                            lng = location?.Element("lng")?.Value;
                        }
                    }
                }

                double value;
                if (double.TryParse(lat, NumberStyles.Float, CultureInfo.InvariantCulture, out value)) note.Latitude = value;
                if (double.TryParse(lng, NumberStyles.Float, CultureInfo.InvariantCulture, out value)) note.Longitude = value;

                _context.Notez.Add(note);
                await _context.SaveChangesAsync();

                string root = Path.Combine(_environment.MapPath("n"));
                await photo.SaveAsAsync(Path.Combine(root, note.ID + ".jpg"));

                try
                {
                    using (Stream s = photo.OpenReadStream())
                        Helper.GenerateThumbnail(s, Path.Combine(root, "t" + note.ID + ".jpg"));
                }
                catch
                {
                    note.FlagStatus = FlagStatus.Invalid;
                    await _context.SaveChangesAsync();
                }

                return RedirectToAction(nameof(Thanks), new { noteID = note.ID });
            }

            return RedirectToAction(nameof(Index));
        }

        public async Task<IActionResult> Create(IFormFile croppedImage1, IFormFile croppedImage2, int distance)
        {

            var uploads = Path.Combine(_environment.WebRootPath, "Uploads");

            if (croppedImage1.Length > 0 && croppedImage2.Length > 0)
            {
                var puzzleImageId = Guid.NewGuid().ToString();
                var fileName = string.Format("{0}.jpg", puzzleImageId);

                await croppedImage1.SaveAsAsync(Path.Combine(uploads, fileName));

                ImageResizer.ImageJob img1 = new ImageResizer.ImageJob(Path.Combine(uploads, fileName), Path.Combine(uploads, "16-9", "400", fileName),
                                new ImageResizer.Instructions("maxheight=400;&scale=both;format=jpg;mode=max"));

                img1.Build();

                ImageResizer.ImageJob img2 = new ImageResizer.ImageJob(Path.Combine(uploads, fileName), Path.Combine(uploads, "16-9", "1065", fileName),
                                                new ImageResizer.Instructions("maxheight=1065;&scale=both;format=jpg;mode=max"));

                img2.Build();


                if (ModelState.IsValid)
                {
                    await _puzzleRepository.AddPuzzleAsync(User, puzzleImageId, distance, _shopRepository.GetUserShop(User).ID);
                }
            }

            return View();

        }

 public async Task<IActionResult> Create(News news, IFormFile uploadFile)
 {
     if (ModelState.IsValid)
     {
         string fileName = Configurations.DefaultFileName;
         if (uploadFile != null)
         {
             //Image uploading
             string uploads = Path.Combine(_environment.WebRootPath, Configurations.NewsImageStockagePath);
             fileName = Guid.NewGuid().ToString() + "_" + ContentDispositionHeaderValue.Parse(uploadFile.ContentDisposition).FileName.Trim('"');
             await uploadFile.SaveAsAsync(Path.Combine(uploads, fileName));
         }
         //Setting value for creation
         news.Id = Guid.NewGuid();
         news.DateOfPublication = DateTime.Now;
         news.ImageLink = Path.Combine(Configurations.NewsImageStockagePath,fileName);
         //TODO Get logged in User and add it to the news
         var appUser = await GetCurrentUserAsync();
         User user;
         user = _context.Consumers.FirstOrDefault(x => x.Email == appUser.Email);
         if(user == null)
         {
             user = _context.Producers.FirstOrDefault(x => x.Email == appUser.Email);
         }
         news.User = user;
         _context.News.Add(news);
         _context.SaveChanges();
         return RedirectToAction("Index");
     }
     return View(news);
 }

 public async Task StoreFileAsync(string fileName, IFormFile formFile, bool overwrite = false)
 {
     var filePath = GetAbsoluteFilePath(fileName);
     if (File.Exists(filePath) && !overwrite)
     {
         throw new Exception("File already exists");
     }
     await formFile.SaveAsAsync(filePath);
 }

 public async Task Post(string name, IFormFile file)
 {
     var beer = new Beer { Name = name };
     if (file != null)
     {
         var filename = ContentDispositionHeaderValue
             .Parse(file.ContentDisposition)
             .FileName
             .Trim('"');
         
         beer.Picture = "http://localhost:5000/Images/" + filename;
         await file.SaveAsAsync("C:\\Code\\personal\\app-to-app-uwp\\Inventory.API\\wwwroot\\Images\\" + filename);
     }
     beers.Add(beer);
 }

 public async Task<IActionResult> Create(IFormFile file)
 {
     try
     {
         var uploads = Path.Combine(_environment.WebRootPath,"uploads");
         var fileName = ContentDispositionHeaderValue.Parse(file.ContentDisposition).FileName.Trim('"');
         FileUpload01.Models.File newFile = new FileUpload01.Models.File();
         newFile.ImagePath = fileName;
         _db.Uploads.Add(newFile);
         _db.SaveChanges();
         await file.SaveAsAsync(Path.Combine(uploads, fileName));
         return RedirectToAction("Index");
     }
     catch (Exception ex)
     {
         System.Diagnostics.Debug.Write(ex);
         return View();
     }
 }

        public async Task<IActionResult> Create(UserStolonViewModel vmConsumer, IFormFile uploadFile)
        {
            if (ModelState.IsValid)
            {
                #region Creating Consumer
                string fileName = Configurations.DefaultFileName;
                if (uploadFile != null)
                {
                    //Image uploading
                    string uploads = Path.Combine(_environment.WebRootPath, Configurations.UserAvatarStockagePath);
                    fileName = Guid.NewGuid().ToString() + "_" + ContentDispositionHeaderValue.Parse(uploadFile.ContentDisposition).FileName.Trim('"');
                    await uploadFile.SaveAsAsync(Path.Combine(uploads, fileName));
                }
                //Setting value for creation
                vmConsumer.Consumer.Avatar = Path.Combine(Configurations.UserAvatarStockagePath, fileName);
                vmConsumer.Consumer.RegistrationDate = DateTime.Now;
                vmConsumer.Consumer.Name = vmConsumer.Consumer.Name.ToUpper();
                _context.Consumers.Add(vmConsumer.Consumer);
                #endregion Creating Consumer

                #region Creating linked application data
                var appUser = new ApplicationUser { UserName = vmConsumer.Consumer.Email, Email = vmConsumer.Consumer.Email };
                appUser.User = vmConsumer.Consumer;
                
                var result = await _userManager.CreateAsync(appUser, vmConsumer.Consumer.Email);
                if (result.Succeeded)
                {
                    //Add user role
                    result = await _userManager.AddToRoleAsync(appUser, vmConsumer.UserRole.ToString());
                    //Add user type
                    result = await _userManager.AddToRoleAsync(appUser, Configurations.UserType.Consumer.ToString());
                }
                #endregion Creating linked application data

                _context.SaveChanges();
                //Send confirmation mail
                Services.AuthMessageSender.SendEmail(vmConsumer.Consumer.Email, vmConsumer.Consumer.Name, "Creation de votre compte", base.RenderPartialViewToString("UserCreatedConfirmationMail", vmConsumer));

                return RedirectToAction("Index");
            }
            return View(vmConsumer);
        }

        public async System.Threading.Tasks.Task<CommonResult<UploadImageResult>> SaveProfileImage(IFormFile file)
        {
            var fileName = Guid.NewGuid().ToString() + ".jpg";

            var filePath = _configurationProvider.GetProfileOriginalImagesFolderPath() + fileName;

            await file.SaveAsAsync(filePath);

            UpdateUserProfileImage(StaticManager.UserName, fileName);

            var image = Image.FromFile(filePath);

            return CommonResult<UploadImageResult>.Success(new UploadImageResult
            {
                Status = "success",
                Width = image.Width,
                Height = image.Height,
                Url = _configurationProvider.GetProfileOriginalImagesFolderInternalPath() + fileName
            });
        }

        public async Task<IActionResult> Create(Barber barber, IFormFile image)
        {
            if (ModelState.IsValid)
            {
                var uploads = Path.Combine(_environment.WebRootPath, "ProfilePicPath");
                if (image != null)
                {
                    var fileName = ContentDispositionHeaderValue.Parse(image.ContentDisposition).FileName.Trim('"');
                    await image.SaveAsAsync(Path.Combine(uploads, fileName));
                    barber.ProfilePicPath = fileName;
                }
                
                _context.Barbers.Add(barber);
                _context.SaveChanges();
                

                return RedirectToAction("Index");
            }
            return View(barber);
        }

        public async Task<IActionResult> Index(IFormFile photo, string query, string latitude, string longitude, string elevation, string zoom, bool found)
        {
            if (photo != null)
            {
                Notez note = new Notez
                {
                    Found = found,
                    Timestamp = DateTimeOffset.Now,
                    UserAgent = Request.Headers["User-Agent"],
                    HostAddress = Context.GetFeature<IHttpConnectionFeature>().RemoteIpAddress.ToString(),
                    LocationRaw = query,
                    Latitude = double.Parse(latitude, CultureInfo.InvariantCulture),
                    Longitude = double.Parse(longitude, CultureInfo.InvariantCulture),
                    Zoom = float.Parse(zoom, CultureInfo.InvariantCulture),
                    Elevation = float.Parse(elevation, CultureInfo.InvariantCulture),
                };

                _context.Notez.Add(note);
                await _context.SaveChangesAsync();

                string root = Path.Combine(_environment.MapPath("n"));
                await photo.SaveAsAsync(Path.Combine(root, note.ID + ".jpg"));

                try
                {
                    using (Stream s = photo.OpenReadStream())
                        Helper.GenerateThumbnail(s, Path.Combine(root, "t" + note.ID + ".jpg"));
                }
                catch
                {
                    note.FlagStatus = FlagStatus.Invalid;
                    await _context.SaveChangesAsync();
                }

                return RedirectToAction(nameof(Index), new { noteID = note.ID });
            }

            return RedirectToAction(nameof(Index));
        }

 public async Task<IActionResult> Edit(ProducerViewModel vmProducer, IFormFile uploadFile, Configurations.Role UserRole)
 {
     if (ModelState.IsValid)
     {
         if (uploadFile != null)
         {
             string uploads = Path.Combine(_environment.WebRootPath, Configurations.UserAvatarStockagePath);
             //Deleting old image
             string oldImage = Path.Combine(uploads, vmProducer.Producer.Avatar);
             if (System.IO.File.Exists(oldImage) && vmProducer.Producer.Avatar != Path.Combine(Configurations.UserAvatarStockagePath, Configurations.DefaultFileName))
                 System.IO.File.Delete(Path.Combine(uploads, vmProducer.Producer.Avatar));
             //Image uploading
             string fileName = Guid.NewGuid().ToString() + "_" + ContentDispositionHeaderValue.Parse(uploadFile.ContentDisposition).FileName.Trim('"');
             await uploadFile.SaveAsAsync(Path.Combine(uploads, fileName));
             //Setting new value, saving
             vmProducer.Producer.Avatar = Path.Combine(Configurations.UserAvatarStockagePath, fileName);
         }
         ApplicationUser producerAppUser = _context.Users.First(x => x.Email == vmProducer.OriginalEmail);
         producerAppUser.Email = vmProducer.Producer.Email;
         _context.Update(producerAppUser);
         //Getting actual roles
         IList<string> roles = await _userManager.GetRolesAsync(producerAppUser);
         if (!roles.Contains(UserRole.ToString()))
         {
             string roleToRemove = roles.FirstOrDefault(x => Configurations.GetRoles().Contains(x));
             await _userManager.RemoveFromRoleAsync(producerAppUser, roleToRemove);
             //Add user role
             await _userManager.AddToRoleAsync(producerAppUser, UserRole.ToString());
         }
         _context.Update(vmProducer.Producer);
         _context.SaveChanges();
         return RedirectToAction("Index");
     }
     return View(vmProducer);
 }

        public async Task<IActionResult> Upload(IFormFile file)
        {
            var id = Request.Form["id"];

            var fileName = ContentDispositionHeaderValue.Parse(file.ContentDisposition).FileName.Trim('"');
            var filePath = GetFilePath(id);

            if (fileName.IsImage())
            {
                Directory.CreateDirectory(filePath);

                var savePath = Path.Combine(filePath, fileName);
                await file.SaveAsAsync(savePath);
            }
            return Json(new { FileName = fileName, FilePath = filePath, Success = true });
        }

        public static async Task<string> UploadAndResizeImageFile(IHostingEnvironment environment, IFormFile uploadFile, string path)
        {
            string uploads = Path.Combine(environment.WebRootPath, path);
            string fileName = Guid.NewGuid().ToString() + "_" + ContentDispositionHeaderValue.Parse(uploadFile.ContentDisposition).FileName.Trim('"');
	    
            await uploadFile.SaveAsAsync(Path.Combine(uploads, fileName));
            return Path.Combine(path,fileName);
        }

        public async Task<JsonResult> UploadFile(IFormFile file)
        {
            string fileName = ContentDispositionHeaderValue.Parse(file.ContentDisposition).FileName.Trim('"');
            string path = this._environment.WebRootPath + @"\file\" + fileName;
            await file.SaveAsAsync(path);
            string url = Request.Scheme + "://" + Request.Host.Value + "/file/" + fileName;
            return this.Json(new {name=fileName, path= url });

        }

        public async Task<ActionResult> CkeditorUploadImage(IFormFile upload, string CKEditorFuncNum, string CKEditor)
        {
            string fileName = ContentDispositionHeaderValue.Parse(upload.ContentDisposition).FileName.Trim('"');
            string format = fileName.Split(".".ToCharArray())[1];
            string newFileName = DateTime.Now.ToString("ddMMyyyyhhmmssffff") + "." + format;
            string path = this._environment.WebRootPath + @"\img\" + newFileName;
            await upload.SaveAsAsync(path);
            string baseUrl = Request.Scheme+"://"+Request.Host.Value;
            return this.Content("<script language='javascript' type = 'text/javascript'> window.parent.CKEDITOR.tools.callFunction(" + CKEditorFuncNum +
                   ", '" + baseUrl + @"/img/" + newFileName + "', '');</script>", "text/html");

        }