C# HTTP POST로 파일을 ashx에 업로드하는 방법 multipart/form-data

Question

큰 파일을 Generic Handler FileUpload.ashx에 업로드하려고합니다.

나는 Fiddler 데이터가 올바른 방법으로 서버에 도달했는지 확인했습니다. 그러나 나는 서버 측에서 성공할 수 없었다.

많은 방법을 시도했지만 데이터를 HttpContext에 저장할 수 없습니다.

나는 이전

context.Request.Files[0]; 
context.Request.Params["file"] 
context.Request["file"]; 

과 다른 일을 시도하고 지금 매우 혼란 메신저. 간단한 HTML 형식 파일을 설정하고 위의 첫 번째 방법을 사용하여 입력 받아, 여기 복잡합니까? 내용에 대한 자체 파서를 작성해야합니까? 더 간단한 방법이 있습니까? 그런데

public void ProcessRequest(HttpContext context) 
{ 
    // what to do here 
} 

사람이 클라이언트와 서버 양쪽에 대한 샘플을 제공 할 수

내 클라이언트는 WinRt과 서버 측 닷넷 4.5

당신은 사람들이 그것을 어떻게 확인 할 수 있습니다

Answer 1

프로젝트 : 여기

https://github.com/maxpavlov/jQuery-File-Upload.MVC3

업로드 된 파일의 수신을 처리하는 주요 코드 :

using System.Collections.Generic; 
using System.IO; 
using System.Linq; 
using System.Web; 
using System.Web.Script.Serialization; 

namespace jQuery_File_Upload.MVC3.Upload 
{ 
    /// <summary> 
    /// Summary description for UploadHandler 
    /// </summary> 
    public class UploadHandler : IHttpHandler 
    { 
     private readonly JavaScriptSerializer js; 

     private string StorageRoot 
     { 
      get { return Path.Combine(System.Web.HttpContext.Current.Server.MapPath("~/Files/")); } //Path should! always end with '/' 
     } 

     public UploadHandler() 
     { 
      js = new JavaScriptSerializer(); 
      js.MaxJsonLength = 41943040; 
     } 

     public bool IsReusable { get { return false; } } 

     public void ProcessRequest(HttpContext context) 
     { 
      context.Response.AddHeader("Pragma", "no-cache"); 
      context.Response.AddHeader("Cache-Control", "private, no-cache"); 

      HandleMethod(context); 
     } 

     // Handle request based on method 
     private void HandleMethod(HttpContext context) 
     { 
      switch (context.Request.HttpMethod) 
      { 
       case "HEAD": 
       case "GET": 
        if (GivenFilename(context)) DeliverFile(context); 
        else ListCurrentFiles(context); 
        break; 

       case "POST": 
       case "PUT": 
        UploadFile(context); 
        break; 

       case "DELETE": 
        DeleteFile(context); 
        break; 

       case "OPTIONS": 
        ReturnOptions(context); 
        break; 

       default: 
        context.Response.ClearHeaders(); 
        context.Response.StatusCode = 405; 
        break; 
      } 
     } 

     private static void ReturnOptions(HttpContext context) 
     { 
      context.Response.AddHeader("Allow", "DELETE,GET,HEAD,POST,PUT,OPTIONS"); 
      context.Response.StatusCode = 200; 
     } 

     // Delete file from the server 
     private void DeleteFile(HttpContext context) 
     { 
      var filePath = StorageRoot + context.Request["f"]; 
      if (File.Exists(filePath)) 
      { 
       File.Delete(filePath); 
      } 
     } 

     // Upload file to the server 
     private void UploadFile(HttpContext context) 
     { 
      var statuses = new List<FilesStatus>(); 
      var headers = context.Request.Headers; 

      if (string.IsNullOrEmpty(headers["X-File-Name"])) 
      { 
       UploadWholeFile(context, statuses); 
      } 
      else 
      { 
       UploadPartialFile(headers["X-File-Name"], context, statuses); 
      } 

      WriteJsonIframeSafe(context, statuses); 
     } 

     // Upload partial file 
     private void UploadPartialFile(string fileName, HttpContext context, List<FilesStatus> statuses) 
     { 
      if (context.Request.Files.Count != 1) throw new HttpRequestValidationException("Attempt to upload chunked file containing more than one fragment per request"); 
      var inputStream = context.Request.Files[0].InputStream; 
      var fullName = StorageRoot + Path.GetFileName(fileName); 

      using (var fs = new FileStream(fullName, FileMode.Append, FileAccess.Write)) 
      { 
       var buffer = new byte[1024]; 

       var l = inputStream.Read(buffer, 0, 1024); 
       while (l > 0) 
       { 
        fs.Write(buffer, 0, l); 
        l = inputStream.Read(buffer, 0, 1024); 
       } 
       fs.Flush(); 
       fs.Close(); 
      } 
      statuses.Add(new FilesStatus(new FileInfo(fullName))); 
     } 

     // Upload entire file 
     private void UploadWholeFile(HttpContext context, List<FilesStatus> statuses) 
     { 
      for (int i = 0; i < context.Request.Files.Count; i++) 
      { 
       var file = context.Request.Files[i]; 

       var fullPath = StorageRoot + Path.GetFileName(file.FileName); 

       file.SaveAs(fullPath); 

       string fullName = Path.GetFileName(file.FileName); 
       statuses.Add(new FilesStatus(fullName, file.ContentLength, fullPath)); 
      } 
     } 

     private void WriteJsonIframeSafe(HttpContext context, List<FilesStatus> statuses) 
     { 
      context.Response.AddHeader("Vary", "Accept"); 
      try 
      { 
       if (context.Request["HTTP_ACCEPT"].Contains("application/json")) 
        context.Response.ContentType = "application/json"; 
       else 
        context.Response.ContentType = "text/plain"; 
      } 
      catch 
      { 
       context.Response.ContentType = "text/plain"; 
      } 

      var jsonObj = js.Serialize(statuses.ToArray()); 
      context.Response.Write(jsonObj); 
     } 

     private static bool GivenFilename(HttpContext context) 
     { 
      return !string.IsNullOrEmpty(context.Request["f"]); 
     } 

     private void DeliverFile(HttpContext context) 
     { 
      var filename = context.Request["f"]; 
      var filePath = StorageRoot + filename; 

      if (File.Exists(filePath)) 
      { 
       context.Response.AddHeader("Content-Disposition", "attachment; filename=\"" + filename + "\""); 
       context.Response.ContentType = "application/octet-stream"; 
       context.Response.ClearContent(); 
       context.Response.WriteFile(filePath); 
      } 
      else 
       context.Response.StatusCode = 404; 
     } 

     private void ListCurrentFiles(HttpContext context) 
     { 
      var files = 
       new DirectoryInfo(StorageRoot) 
        .GetFiles("*", SearchOption.TopDirectoryOnly) 
        .Where(f => !f.Attributes.HasFlag(FileAttributes.Hidden)) 
        .Select(f => new FilesStatus(f)) 
        .ToArray(); 

      string jsonObj = js.Serialize(files); 
      context.Response.AddHeader("Content-Disposition", "inline; filename=\"files.json\""); 
      context.Response.Write(jsonObj); 
      context.Response.ContentType = "application/json"; 
     } 

    } 
}