Estou trabalhando em um serviço da Web usando a nova WebAPI do ASP.NET MVC que servirá arquivos binários, principalmente .cabe .exearquivos.

O seguinte método do controlador parece funcionar, o que significa que ele retorna um arquivo, mas está configurando o tipo de conteúdo para application/json:

public HttpResponseMessage<Stream> Post(string version, string environment, string filetype)
{
    var path = @"C:\Temp\test.exe";
    var stream = new FileStream(path, FileMode.Open);
    return new HttpResponseMessage<Stream>(stream, new MediaTypeHeaderValue("application/octet-stream"));
}

Existe uma maneira melhor de fazer isso?

Tente usar um simples HttpResponseMessagecom sua Contentpropriedade definida como StreamContent:

// using System.IO;
// using System.Net.Http;
// using System.Net.Http.Headers;

public HttpResponseMessage Post(string version, string environment,
    string filetype)
{
    var path = @"C:\Temp\test.exe";
    HttpResponseMessage result = new HttpResponseMessage(HttpStatusCode.OK);
    var stream = new FileStream(path, FileMode.Open, FileAccess.Read);
    result.Content = new StreamContent(stream);
    result.Content.Headers.ContentType = 
        new MediaTypeHeaderValue("application/octet-stream");
    return result;
}

Algumas coisas a serem observadas sobre o streamusado:

• Você não deve ligar stream.Dispose(), pois a API da Web ainda precisa acessá-la quando processar o método do controlador resultpara enviar dados de volta ao cliente. Portanto, não use um using (var stream = …)bloco. A API da Web descartará o fluxo para você.

• Verifique se o fluxo tem sua posição atual definida como 0 (ou seja, o início dos dados do fluxo). No exemplo acima, isso é um dado, pois você acabou de abrir o arquivo. No entanto, em outros cenários (como quando você escreve pela primeira vez alguns dados binários em a MemoryStream), certifique-se de stream.Seek(0, SeekOrigin.Begin);definirstream.Position = 0;

• Com os fluxos de arquivos, especificar explicitamente a FileAccess.Readpermissão pode ajudar a evitar problemas de direitos de acesso nos servidores da Web; As contas do pool de aplicativos IIS geralmente recebem apenas direitos de leitura / lista / execução de acesso ao wwwroot.

Para a API da Web 2 , você pode implementar IHttpActionResult. Aqui está o meu:

using System;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web;
using System.Web.Http;

class FileResult : IHttpActionResult
{
    private readonly string _filePath;
    private readonly string _contentType;

    public FileResult(string filePath, string contentType = null)
    {
        if (filePath == null) throw new ArgumentNullException("filePath");

        _filePath = filePath;
        _contentType = contentType;
    }

    public Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
    {
        var response = new HttpResponseMessage(HttpStatusCode.OK)
        {
            Content = new StreamContent(File.OpenRead(_filePath))
        };

        var contentType = _contentType ?? MimeMapping.GetMimeMapping(Path.GetExtension(_filePath));
        response.Content.Headers.ContentType = new MediaTypeHeaderValue(contentType);

        return Task.FromResult(response);
    }
}

Então, algo como isso no seu controlador:

[Route("Images/{*imagePath}")]
public IHttpActionResult GetImage(string imagePath)
{
    var serverPath = Path.Combine(_rootPath, imagePath);
    var fileInfo = new FileInfo(serverPath);

    return !fileInfo.Exists
        ? (IHttpActionResult) NotFound()
        : new FileResult(fileInfo.FullName);
}

E aqui está uma maneira de dizer ao IIS para ignorar solicitações com uma extensão, para que a solicitação chegue ao controlador:

<!-- web.config -->
<system.webServer>
  <modules runAllManagedModulesForAllRequests="true"/>

Para aqueles que usam o .NET Core:

Você pode usar a interface IActionResult em um método de controlador de API, assim ...

    [HttpGet("GetReportData/{year}")]
    public async Task<IActionResult> GetReportData(int year)
    {
        // Render Excel document in memory and return as Byte[]
        Byte[] file = await this._reportDao.RenderReportAsExcel(year);

        return File(file, "application/vnd.openxmlformats", "fileName.xlsx");
    }

Este exemplo é simplificado, mas deve passar o ponto. Em .NET Núcleo esse processo é por isso muito mais simples do que nas versões anteriores do .NET - ou seja, nenhum tipo de resposta definição, conteúdo, cabeçalhos, etc.

Além disso, é claro que o tipo MIME do arquivo e a extensão dependerão das necessidades individuais.

Referência: SO Postar resposta por @NKosi

Enquanto a solução sugerida funciona bem, há outra maneira de retornar uma matriz de bytes do controlador, com o fluxo de resposta formatado corretamente:

• Na solicitação, defina o cabeçalho "Accept: application / octet-stream".
• No servidor, adicione um formatador de tipo de mídia para suportar esse tipo de mímica.

Infelizmente, o WebApi não inclui nenhum formatador para "application / octet-stream". Há uma implementação aqui no GitHub: BinaryMediaTypeFormatter (há pequenas adaptações para fazê-lo funcionar na webapi 2, as assinaturas de método foram alteradas).

Você pode adicionar este formatador à sua configuração global:

HttpConfiguration config;
// ...
config.Formatters.Add(new BinaryMediaTypeFormatter(false));

Agora, o WebApi deve ser usado BinaryMediaTypeFormatterse a solicitação especificar o cabeçalho Aceitar correto.

Eu prefiro esta solução porque um controlador de ação retornando byte [] é mais confortável para testar. No entanto, a outra solução permite maior controle se você deseja retornar outro tipo de conteúdo que não seja "application / octet-stream" (por exemplo, "image / gif").

Para qualquer pessoa que tenha o problema de a API ser chamada mais de uma vez durante o download de um arquivo bastante grande usando o método na resposta aceita, defina o buffer de resposta como true System.Web.HttpContext.Current.Response.Buffer = true;

Isso garante que todo o conteúdo binário seja armazenado em buffer no servidor antes de ser enviado ao cliente. Caso contrário, você verá várias solicitações sendo enviadas ao controlador e, se não tratá-las adequadamente, o arquivo ficará corrompido.

A sobrecarga que você está usando define a enumeração dos formatadores de serialização. Você precisa especificar o tipo de conteúdo explicitamente, como:

httpResponseMessage.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");

Você poderia tentar

httpResponseMessage.Content.Headers.Add("Content-Type", "application/octet-stream");