web-dev-qa-db-fra.com

ASP API Web .Net téléchargeant des images au format binaire

Je souhaite essayer d'utiliser l'API Web pour passer un appel mais je souhaite que la réponse soit l'image binaire réelle stockée dans une base de données, et non une chaîne codée JSON en base64 Quelqu'un a des indications à ce sujet?

Update - C’est ce que j’ai mis en place:

 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;
asp.netrestasp.net-web-api
30
spaceagestereo

Vous pouvez définir le contenu de la réponse sur un objet 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);
29
Mike Wasson

Bien que cela ait été marqué comme réponse, ce n'était pas tout à fait ce que je voulais, alors j'ai continué à chercher. Maintenant que j'ai compris, voici ce que j'ai:

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");
}

Certes, c'est pour obtenir une image via une URL. Si vous voulez simplement récupérer une image sur le serveur de fichiers, j'imagine que vous remplacez cette ligne:

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

Avec ça:

using (Bitmap image = new Bitmap(myFilePath))

EDIT: Peu importe, c'est pour MVC ordinaire. pour l'API Web, j'ai ceci:

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;
}

Ce qui est assez similaire à ce que l'OP a.

18
vbullinger

J'ai fait cette chose exacte. Voici mon code:

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;
                        }
                    }
                }

Et ensuite sur le client:

                    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;
                }
1
aBetterGamer

Cette tâche s’effectue très facilement sans à l’aide de WebAPI. J'implémenterais un gestionnaire HTTP personnalisé pour une extension unique et renverrais la réponse binaire à cet emplacement. Le plus est que vous pouvez également modifier les en-têtes de réponse HTTP et le type de contenu, de sorte que vous avez un contrôle absolu sur ce qui est renvoyé.

Vous pouvez concevoir un modèle d'URL (en définissant comment vous savez quelle image retourner en fonction de son URL) et conserver ces URL dans vos ressources d'API. Une fois que l'URL est renvoyée dans la réponse de l'API, elle peut être directement demandée par le navigateur et atteindra votre gestionnaire HTTP, renvoyant ainsi l'image correcte.

Les images ont un contenu statique et ont leur propre rôle dans HTTP et HTML. Inutile de les mélanger avec le JSON utilisé lors de l'utilisation d'une API.

0
Slavo