ASP .Net Web API descargando imágenes como binario

Question

Quiero intentar utilizar la API web hacer una llamada a reposo pero quiero que la respuesta sea la imagen binaria real almacenada en una base de datos, no una cadena codificada JSON base64. Alguien tiene algunos consejos sobre esto?

Update- Esto es lo que terminó de aplicación:

HttpResponseMessage result = new HttpResponseMessage(HttpStatusCode.OK); 
result.Content = new StreamContent(new MemoryStream(profile.Avatar)); 
result.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream"); 
result.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment"); 
result.Content.Headers.ContentDisposition.FileName = "avatar.png"; 
return result; 

Answer 1

puede establecer el contenido de la respuesta a un objeto StreamContent:

 var fileStream = new FileStream(path, FileMode.Open); 

     var resp = new HttpResponseMessage() 
     { 
      Content = new StreamContent(fileStream) 
     }; 

     // Find the MIME type 
     string mimeType = _extensions[Path.GetExtension(path)]; 
     resp.Content.Headers.ContentType = new MediaTypeHeaderValue(mimeType); 

Answer 2

Esta tarea se logra mucho más fácilmente y sin usando WebAPI. Implementaría un HTTP handler personalizado para una extensión única, y devolvería la respuesta binaria allí. Lo mejor es que también puede modificar los encabezados de respuesta HTTP y el tipo de contenido, para que tenga control absoluto sobre lo que se devuelve.

Puede diseñar un patrón de URL (que define cómo sabe qué imagen debe devolver en función de su URL) y mantener esas URL en sus recursos de API. Una vez que la URL se devuelve en la respuesta de la API, puede ser solicitada directamente por el navegador y llegará a su controlador HTTP, devolviendo la imagen correcta.

Las imágenes son de contenido estático y tienen su propio rol en HTTP y HTML, sin necesidad de mezclarlas con el JSON que se usa cuando se trabaja con una API.

Answer 3

Si bien esto se marcó como respondido, no era exactamente lo que yo quería, así que seguí buscando. Ahora que he averiguado, esto es lo que tengo:

public FileContentResult GetFile(string id) 
{ 
    byte[] fileContents; 
    using (MemoryStream memoryStream = new MemoryStream()) 
    { 
     using (Bitmap image = new Bitmap(WebRequest.Create(myURL).GetResponse().GetResponseStream())) 
      image.Save(memoryStream, ImageFormat.Jpeg); 
     fileContents = memoryStream.ToArray(); 
    } 
    return new FileContentResult(fileContents, "image/jpg"); 
} 

Por supuesto, eso es para conseguir una imagen a través de una URL. Si lo que desea es tomar una imagen fuera del servidor de archivos, me imagino que cambie esta línea:

using (Bitmap image = new Bitmap(WebRequest.Create(myURL).GetResponse().GetResponseStream())) 

Con esta:

using (Bitmap image = new Bitmap(myFilePath)) 

EDIT: No importa, esto es para MVC regular. para Web API, tengo esto:

public HttpResponseMessage Get(string id) 
{ 
    string fileName = string.Format("{0}.jpg", id); 
    if (!FileProvider.Exists(fileName)) 
     throw new HttpResponseException(HttpStatusCode.NotFound); 

    FileStream fileStream = FileProvider.Open(fileName); 
    HttpResponseMessage response = new HttpResponseMessage { Content = new StreamContent(fileStream) }; 
    response.Content.Headers.ContentType = new MediaTypeHeaderValue("image/jpg"); 
    response.Content.Headers.ContentLength = FileProvider.GetLength(fileName); 
    return response; 
} 

Cual es bastante similar a lo que OP tiene.

Answer 4

Hice esto exactamente. Aquí está mi código:

if (!String.IsNullOrWhiteSpace(imageName)) 
       { 
        var savedFileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, Path.Combine(uploadPath, imageName)); 
        var image = System.Drawing.Image.FromFile(savedFileName); 

        if (ImageFormat.Jpeg.Equals(image.RawFormat)) 
        { 
         // JPEG 
         using(var memoryStream = new MemoryStream()) 
         { 
          image.Save(memoryStream, ImageFormat.Jpeg); 

          var result = new HttpResponseMessage(HttpStatusCode.OK) 
           { 
            Content = new ByteArrayContent(memoryStream.ToArray()) 
           }; 

          result.Content.Headers.ContentType = new MediaTypeHeaderValue("image/jpeg"); 
          result.Content.Headers.ContentLength = memoryStream.Length; 

          return result; 
         } 
        } 
        else if (ImageFormat.Png.Equals(image.RawFormat)) 
        { 
         // PNG 
         using (var memoryStream = new MemoryStream()) 
         { 
          image.Save(memoryStream, ImageFormat.Png); 

          var result = new HttpResponseMessage(HttpStatusCode.OK) 
          { 
           Content = new ByteArrayContent(memoryStream.ToArray()) 
          }; 

          result.Content.Headers.ContentType = new MediaTypeHeaderValue("image/png"); 
          result.Content.Headers.ContentLength = memoryStream.Length; 

          return result; 
         } 
        } 
        else if (ImageFormat.Gif.Equals(image.RawFormat)) 
        { 
         // GIF 
         using (var memoryStream = new MemoryStream()) 
         { 
          image.Save(memoryStream, ImageFormat.Gif); 

          var result = new HttpResponseMessage(HttpStatusCode.OK) 
          { 
           Content = new ByteArrayContent(memoryStream.ToArray()) 
          }; 

          result.Content.Headers.ContentType = new MediaTypeHeaderValue("image/gif"); 
          result.Content.Headers.ContentLength = memoryStream.Length; 

          return result; 
         } 
        } 
       } 

Y luego en el cliente:

    var client = new HttpClient(); 
        var imageName = product.ImageUrl.Replace("~/Uploads/", ""); 
       var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, 
             Properties.Settings.Default.DeviceMediaPath + "\\" + imageName); 

       var response = 
        client.GetAsync(apiUrl + "/Image?apiLoginId=" + apiLoginId + "&authorizationToken=" + authToken + 
            "&imageName=" + product.ImageUrl.Replace("~/Uploads/","")).Result; 

       if (response.IsSuccessStatusCode) 
       { 
        var data = response.Content.ReadAsByteArrayAsync().Result; 
        using (var ms = new MemoryStream(data)) 
        { 
         using (var fs = File.Create(path)) 
         { 
          ms.CopyTo(fs); 
         } 
        } 

        result = true; 
       } 
       else 
       { 
        result = false; 
        break; 
       }