c# - Como aceitar um arquivo POST




asp.net-mvc-4 (11)

Estou usando o asp.net mvc 4 webapi beta para construir um serviço de descanso. Eu preciso ser capaz de aceitar imagens / arquivos POST de aplicativos clientes. Isso é possível usando o webapi? Abaixo está como a ação que estou usando atualmente. Alguém sabe de um exemplo de como isso deve funcionar?

[HttpPost]
public string ProfileImagePost(HttpPostedFile profileImage)
{
    string[] extensions = { ".jpg", ".jpeg", ".gif", ".bmp", ".png" };
    if (!extensions.Any(x => x.Equals(Path.GetExtension(profileImage.FileName.ToLower()), StringComparison.OrdinalIgnoreCase)))
    {
        throw new HttpResponseException("Invalid file type.", HttpStatusCode.BadRequest);
    }

    // Other code goes here

    return "/path/to/image.png";
}

Answers

veja http://www.asp.net/web-api/overview/formats-and-model-binding/html-forms-and-multipart-mime#multipartmime , embora eu ache que o artigo faz parecer um pouco mais complicado do que é realmente.

Basicamente,

public Task<HttpResponseMessage> PostFile() 
{ 
    HttpRequestMessage request = this.Request; 
    if (!request.Content.IsMimeMultipartContent()) 
    { 
        throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); 
    } 

    string root = System.Web.HttpContext.Current.Server.MapPath("~/App_Data/uploads"); 
    var provider = new MultipartFormDataStreamProvider(root); 

    var task = request.Content.ReadAsMultipartAsync(provider). 
        ContinueWith<HttpResponseMessage>(o => 
    { 

        string file1 = provider.BodyPartFileNames.First().Value;
        // this is the file name on the server where the file was saved 

        return new HttpResponseMessage() 
        { 
            Content = new StringContent("File uploaded.") 
        }; 
    } 
    ); 
    return task; 
} 

Estou surpreso que muitos de vocês parecem querer salvar arquivos no servidor. Solução para manter tudo na memória é a seguinte:

[HttpPost, Route("api/upload")]
public async Task<IHttpActionResult> Upload()
{
    if (!Request.Content.IsMimeMultipartContent())
        throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); 

    var provider = new MultipartMemoryStreamProvider();
    await Request.Content.ReadAsMultipartAsync(provider);
    foreach (var file in provider.Contents)
    {
        var filename = file.Headers.ContentDisposition.FileName.Trim('\"');
        var buffer = await file.ReadAsByteArrayAsync();
        //Do whatever you want with filename and its binary data.
    }

    return Ok();
}

Veja o código abaixo, adaptado deste artigo , que demonstra o código de exemplo mais simples que encontrei. Inclui uploads de arquivos e de memória (mais rápidos).

public HttpResponseMessage Post()
{
    var httpRequest = HttpContext.Current.Request;
    if (httpRequest.Files.Count < 1)
    {
        return Request.CreateResponse(HttpStatusCode.BadRequest);
    }

    foreach(string file in httpRequest.Files)
    {
        var postedFile = httpRequest.Files[file];
        var filePath = HttpContext.Current.Server.MapPath("~/" + postedFile.FileName);
        postedFile.SaveAs(filePath);
        // NOTE: To store in memory use postedFile.InputStream
    }

    return Request.CreateResponse(HttpStatusCode.Created);
}

Esta pergunta tem muitas boas respostas mesmo para o .Net Core. Eu estava usando ambos os Frameworks, os exemplos de código fornecidos funcionam bem. Então não vou repetir. No meu caso, o importante foi como usar as ações de upload de arquivos com Swagger assim:

Aqui está minha recapitulação:

ASP .Net WebAPI 2

  • Para fazer o upload do arquivo use: MultipartFormDataStreamProvider veja as respostas aqui
  • Como usá-lo com o Swagger

.NET Core


Eu tive um problema semelhante para a API da Web de visualização. Não portou essa parte para o novo MVC 4 Web API ainda, mas talvez isso ajude:

Upload de arquivo REST com HttpRequestMessage ou Stream?

Por favor, deixe-me saber, pode se sentar amanhã e tentar implementá-lo novamente.


Aqui estão duas maneiras de aceitar um arquivo. Um usando no provedor de memória MultipartMemoryStreamProvider e um usando MultipartFormDataStreamProvider que salva em um disco. Note que isto é apenas para um upload de arquivo de cada vez. Você pode certamente estender isso para salvar vários arquivos. A segunda abordagem pode suportar arquivos grandes. Eu testei arquivos com mais de 200MB e funciona bem. Usando na abordagem de memória não requer que você salve no disco, mas jogará fora da exceção de memória se você exceder um certo limite.

        private async Task<Stream> ReadStream()
    {
        Stream stream = null;
        var provider = new MultipartMemoryStreamProvider();
        await Request.Content.ReadAsMultipartAsync(provider);
        foreach (var file in provider.Contents)
        {
            var buffer = await file.ReadAsByteArrayAsync();
            stream = new MemoryStream(buffer);
        }

        return stream;
    }

private async Task<Stream> ReadLargeStream()
    {
        Stream stream = null;
        string root = Path.GetTempPath();
        var provider = new MultipartFormDataStreamProvider(root);
        await Request.Content.ReadAsMultipartAsync(provider);
        foreach (var file in provider.FileData)
        {
            var path = file.LocalFileName;
            byte[] content = File.ReadAllBytes(path);
            File.Delete(path);
            stream = new MemoryStream(content);
        }

        return stream;
    }

[HttpPost]
public JsonResult PostImage(HttpPostedFileBase file)
{
    try
    {
        if (file != null && file.ContentLength > 0 && file.ContentLength<=10485760)
        {
            var fileName = Path.GetFileName(file.FileName);                                        

            var path = Path.Combine(Server.MapPath("~/") + "HisloImages" + "\\", fileName);

            file.SaveAs(path);
            #region MyRegion
            ////save imag in Db
            //using (MemoryStream ms = new MemoryStream())
            //{
            //    file.InputStream.CopyTo(ms);
            //    byte[] array = ms.GetBuffer();
            //} 
            #endregion
            return Json(JsonResponseFactory.SuccessResponse("Status:0 ,Message: OK"), JsonRequestBehavior.AllowGet);
        }
        else
        {
            return Json(JsonResponseFactory.ErrorResponse("Status:1 , Message: Upload Again and File Size Should be Less Than 10MB"), JsonRequestBehavior.AllowGet);
        }
    }
    catch (Exception ex)
    {

        return Json(JsonResponseFactory.ErrorResponse(ex.Message), JsonRequestBehavior.AllowGet);

    }
}

Aqui está uma solução rápida e suja que leva o conteúdo do arquivo carregado do corpo HTTP e o grava em um arquivo. Eu incluí um snippet HTML / JS "bare bones" para o upload do arquivo.

Método da API da Web:

[Route("api/myfileupload")]        
[HttpPost]
public string MyFileUpload()
{
    var request = HttpContext.Current.Request;
    var filePath = "C:\\temp\\" + request.Headers["filename"];
    using (var fs = new System.IO.FileStream(filePath, System.IO.FileMode.Create))
    {
        request.InputStream.CopyTo(fs);
    }
    return "uploaded";
}

Upload de arquivo HTML:

<form>
    <input type="file" id="myfile"/>  
    <input type="button" onclick="uploadFile();" value="Upload" />
</form>
<script type="text/javascript">
    function uploadFile() {        
        var xhr = new XMLHttpRequest();                 
        var file = document.getElementById('myfile').files[0];
        xhr.open("POST", "api/myfileupload");
        xhr.setRequestHeader("filename", file.name);
        xhr.send(file);
    }
</script>

Eu usei a resposta de Mike Wasson antes de atualizar todas as NuGets no meu projeto webapi mvc4. Depois disso, tive que reescrever a ação de upload do arquivo:

    public Task<HttpResponseMessage> Upload(int id)
    {
        HttpRequestMessage request = this.Request;
        if (!request.Content.IsMimeMultipartContent())
        {
            throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.UnsupportedMediaType));
        }

        string root = System.Web.HttpContext.Current.Server.MapPath("~/App_Data/uploads");
        var provider = new MultipartFormDataStreamProvider(root);

        var task = request.Content.ReadAsMultipartAsync(provider).
            ContinueWith<HttpResponseMessage>(o =>
            {
                FileInfo finfo = new FileInfo(provider.FileData.First().LocalFileName);

                string guid = Guid.NewGuid().ToString();

                File.Move(finfo.FullName, Path.Combine(root, guid + "_" + provider.FileData.First().Headers.ContentDisposition.FileName.Replace("\"", "")));

                return new HttpResponseMessage()
                {
                    Content = new StringContent("File uploaded.")
                };
            }
        );
        return task;
    }

Aparentemente, BodyPartFileNames não está mais disponível no MultipartFormDataStreamProvider.


Para essas mesmas direções, estou postando um cliente e servidor snipets que enviam arquivos do Excel usando o WebApi, c # 4:

public static void SetFile(String serviceUrl, byte[] fileArray, String fileName)
{
    try
    {
        using (var client = new HttpClient())
        {
                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                using (var content = new MultipartFormDataContent())
                {
                    var fileContent = new ByteArrayContent(fileArray);//(System.IO.File.ReadAllBytes(fileName));
                    fileContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
                    {
                        FileName = fileName
                    };
                    content.Add(fileContent);
                    var result = client.PostAsync(serviceUrl, content).Result;
                }
        }
    }
    catch (Exception e)
    {
        //Log the exception
    }
}

E o controlador webapi do servidor:

public Task<IEnumerable<string>> Post()
{
    if (Request.Content.IsMimeMultipartContent())
    {
        string fullPath = HttpContext.Current.Server.MapPath("~/uploads");
        MyMultipartFormDataStreamProvider streamProvider = new MyMultipartFormDataStreamProvider(fullPath);
        var task = Request.Content.ReadAsMultipartAsync(streamProvider).ContinueWith(t =>
        {
            if (t.IsFaulted || t.IsCanceled)
                    throw new HttpResponseException(HttpStatusCode.InternalServerError);

            var fileInfo = streamProvider.FileData.Select(i =>
            {
                var info = new FileInfo(i.LocalFileName);
                return "File uploaded as " + info.FullName + " (" + info.Length + ")";
            });
            return fileInfo;

        });
        return task;
    }
    else
    {
        throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotAcceptable, "Invalid Request!"));
    }
}

E o Custom MyMultipartFormDataStreamProvider, necessário para personalizar o nome do arquivo:

PS: Eu peguei esse código de outro post http://www.codeguru.com/csharp/.net/uploading-files-asynchronously-using-asp.net-web-api.htm

public class MyMultipartFormDataStreamProvider : MultipartFormDataStreamProvider
{
    public MyMultipartFormDataStreamProvider(string path)
        : base(path)
    {

    }

    public override string GetLocalFileName(System.Net.Http.Headers.HttpContentHeaders headers)
    {
        string fileName;
        if (!string.IsNullOrWhiteSpace(headers.ContentDisposition.FileName))
        {
            fileName = headers.ContentDisposition.FileName;
        }
        else
        {
            fileName = Guid.NewGuid().ToString() + ".data";
        }
        return fileName.Replace("\"", string.Empty);
    }
}

A questão parece muito simples, mas a resposta é um pouco complicada. Se você ver quase todo mundo sugeriu usar a classe Random e alguns sugeriram usar a classe de criptografia RNG. Mas então quando escolher o que.

Para isso, precisamos primeiro entender o termo RANDOMNESS e a filosofia por trás dele.

Gostaria de encorajá-lo a assistir este vídeo que vai em profundidade na filosofia da RANDOMNESS usando C # https://www.youtube.com/watch?v=tCYxc-2-3fY

Primeira coisa, vamos entender a filosofia da RANDOMNESS. Quando dizemos a uma pessoa para escolher entre VERMELHO, VERDE e AMARELO o que acontece internamente. O que faz uma pessoa escolher VERMELHO ou AMARELO ou VERDE?

Algum pensamento inicial entra na mente das pessoas que decide sua escolha, pode ser a cor favorita, a cor da sorte e assim por diante. Em outras palavras, um gatilho inicial que denominamos de RANDOM como SEED. Este SEED é o ponto inicial, o gatilho que o instiga a selecionar o valor RANDOM.

Agora, se um SEED é fácil de adivinhar, então esse tipo de número aleatório é denominado PSEUDO e, quando uma semente é difícil de adivinhar, esses números aleatórios são denominados números aleatórios SECURED .

Por exemplo, uma pessoa escolhe a cor dependendo da combinação de clima e som, então seria difícil adivinhar a semente inicial.

Agora deixe-me fazer uma declaração importante:

* A classe “Random” gera apenas um número aleatório PSEUDO e para gerar o número aleatório SECURE, precisamos usar a classe “RNGCryptoServiceProvider”.

A classe aleatória pega valores iniciais do clock da CPU, o que é muito previsível. Então, em outras palavras, a classe RANDOM de C # gera números pseudo-aleatórios, abaixo está o código para o mesmo.

Random rnd= new Random();
int rndnumber = rnd.Next()

Enquanto a classe RNGCryptoServiceProvider usa a entropia do sistema operacional para gerar sementes. A entropia do sistema operacional é um valor aleatório que é gerado usando o som, o clique do mouse e o tempo do teclado, a temperatura térmica etc. Abaixo, o código para o mesmo.

using (RNGCryptoServiceProvider rg = new RNGCryptoServiceProvider()) 
{ 
  byte[] rno = new byte[5];    
  rg.GetBytes(rno);    
  int randomvalue = BitConverter.ToInt32(rno, 0); 
}

Para entender a entropia do sistema operacional, veja este vídeo a partir das 14:30 https://www.youtube.com/watch?v=tCYxc-2-3fY onde a lógica da entropia do sistema operacional é explicada. Por isso, colocando palavras simples, o RNG Crypto gera números aleatórios SECURE.







c# asp.net-mvc-4