.Net De Base De Manipulation De L'Image (Recadrage Et Redimensionnement) / Gestion Des Fichiers

ImageSharp

ImageSharp est une nouvelle API graphique 2D, entièrement gérée, multi-plateforme, entièrement équipée.

conçu pour démocratiser le traitement d'image, ImageSharp vous apporte une API incroyablement puissante et pourtant magnifiquement simple.

comparé à System.Drawing nous avons pu développer quelque chose de beaucoup plus flexible, plus facile à coder, et beaucoup, beaucoup moins enclin à la mémoire fuite. Il n'y a plus de verrous de processus à l'échelle du système; les images ImageSharp sont sans fil et entièrement supportées dans les environnements web.

construit selon la norme .net 1.1 ImageSharp peut être utilisé dans les scénarios device, cloud, et embedded/IoT.

Vous pouvez utiliser le Microsoft ASP.NET services JavaScript de base pour invoquer des paquets npm arbitraires à l'exécution à partir du code .NET ce qui signifie que vous pouvez choisir n'importe quel paquet npm qui fournit une mise à l'échelle de l'image et l'invoquer.

l'exemple suivant montre comment utiliser JavaScriptServices pour redimensionner l'image https://github.com/aspnet/JavaScriptServices/tree/dev/samples/misc/NodeServicesExamples

Hope qui Aide

pour compléter la réponse @Hossam Barakat, vous pouvez utiliser le Microsoft ASP.NET services JavaScript de base pour invoquer des paquets npm arbitraires à l'exécution à partir du code .NET ce qui signifie que vous pouvez choisir n'importe quel paquet npm qui fournit une mise à l'échelle de l'image et l'invoquer.

L'exemple de l'utilisation de la sharp module, qui a beaucoup de dépendances. Si vous visez plutôt, comme moi, d'utiliser jimp qui est pur javascript:

Démarrage.cs

public class Startup
{
 ...
    // This method gets called by the runtime. Use this method to add services to the container.
    public void ConfigureServices(IServiceCollection services)
    {
        // Enable Node Services
        services.AddNodeServices();
...
    }
...
}

ImageController.cs

using System;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.NodeServices;
using Microsoft.AspNetCore.StaticFiles;
using System.Security.Cryptography;
using System.Text;

namespace NodeServicesExamples.Controllers
{
    public class ResizeImageController : Controller
    {
        private const int MaxDimension = 1000;
        private static string[] AllowedMimeTypes = new[] { "image/jpeg", "image/png", "image/gif" };

        private IHostingEnvironment _environment;
        private INodeServices _nodeServices;

        public ResizeImageController(IHostingEnvironment environment, INodeServices nodeServices)
        {
            _environment = environment;
            _nodeServices = nodeServices;
        }

        [Route("resize/{*imagePath}")]
        [ResponseCache(Duration = 3600)]
        public async Task<IActionResult> Index(string imagePath, double maxWidth, double maxHeight)
        {
            // Validate incoming params
            if (maxWidth < 0 || maxHeight < 0 || maxWidth > MaxDimension || maxHeight > MaxDimension
                || (maxWidth + maxHeight) == 0)
            {
                return BadRequest("Invalid dimensions");
            }

            var mimeType = GetContentType(imagePath);
            if (Array.IndexOf(AllowedMimeTypes, mimeType) < 0)
            {
                return BadRequest("Disallowed image format");
            }

            // Locate source image on disk
            var fileInfo = _environment.WebRootFileProvider.GetFileInfo(imagePath);
            if (!fileInfo.Exists)
            {
                return NotFound();
            }

            var eTag = GenerateETag(Encoding.UTF8.GetBytes($"{fileInfo.LastModified.ToString("s")}-{fileInfo.Length}"));
            HttpContext.Response.Headers["ETag"] = eTag;

            var match = HttpContext.Request.Headers["If-None-Match"].FirstOrDefault();
            if (eTag == match)
            {
                return StatusCode(304);
            }

            // Invoke Node and pipe the result to the response
            var imageStream = await _nodeServices.InvokeAsync<Stream>(
                "./Node/resizeImage",
                fileInfo.PhysicalPath,
                mimeType,
                maxWidth,
                maxHeight);

            return File(imageStream, mimeType, fileInfo.Name);
        }

        private string GetContentType(string path)
        {
            string result;
            return new FileExtensionContentTypeProvider().TryGetContentType(path, out result) ? result : null;
        }

        private string GenerateETag(byte[] data)
        {
            string ret = string.Empty;

            using (var md5 = MD5.Create())
            {
                var hash = md5.ComputeHash(data);
                string hex = BitConverter.ToString(hash);
                ret = hex.Replace("-", "");
            }

            return ret;
        }

    }
}

Noeud\resizeImage.js

var jimp = require("jimp");

module.exports = function (result, physicalPath, mimeType, maxWidth, maxHeight) {
    // Invoke the 'jimp' NPM module, and have it pipe the resulting image data back to .NET
    jimp.read(physicalPath).then(function (file) {
        var width = maxWidth || jimp.AUTO;
        var height = maxHeight || jimp.AUTO;
        file.resize(maxWidth, height)
             .getBuffer(mimeType, function (err, buffer) {
                 var stream = result.stream;
                 stream.write(buffer);
                 stream.end();
             });
    }).catch(function (err) {
        console.error(err);
    });
};

installer jimp: npm install jimp --save

.NET de Base de Traitement d'Image blog (19 janvier 2017) compare les 6 bibliothèques:

• CoreCompat.Système.Dessin
• ImageSharp
• Magick.NET (windows uniquement)
• SkiaSharp
• FreeImage-dotnet-core
• MagicScaler

Feb 26 mise à jour: post a été mis à jour, deux nouveaux paquets ajoutés

réponse Courte est non, pas encore. La plupart sinon toutes les bibliothèques actuelles dépendent du système.Dessin. Si vous avez besoin de cela maintenant, je suivrais cette voie et j'ajouterais système.Dessin.

l'équipe de .NET travaille actuellement sur les fonctionnalités manquantes sur la pile Core 1.0, mais celle-ci n'est pas assez élevée sur leur liste prioritaire: Lien

il s'agit d'une bibliothèque à regarder car ils sont très proches d'une API diffusable sans système.Dessin. : ImageSharp