sommaire
2
3

Optimisation des images pour le web avec .NET (C#)

Introduction

Dans le monde numérique d’aujourd’hui, les images jouent un rôle crucial pour l’expérience utilisateur. En cherchant des logiciels pour redimensionner mes images et créer des miniatures, j’ai constaté que la plupart étaient payants, même pour des besoins aussi simples que les miens. Ce dont j’avais besoin, c’était d’un outil capable de convertir mes images en différentes tailles et dans un format optimisé pour Google, et ce, de manière simple et efficace.

Dans cet article, nous allons explorer comment utiliser C# et la bibliothèque ImageProcessor pour convertir automatiquement vos images en différents formats et tailles. Ce faisant, vous optimiserez les performances de votre site web.

Prérequis

Avant de plonger dans le code, assurez-vous d’avoir installé les packages NuGet suivants :

  • ImageProcessor
  • ImageProcessor.Plugins.WebP

Vous pouvez les installer via la console du gestionnaire de paquets en exécutant les commandes suivantes :

Install-Package ImageProcessor -Version 2.9.1
Install-Package ImageProcessor.Plugins.WebP -Version 1.3.0

Le Code

Voici le code source complet qui effectue la conversion :

using System;
using System.IO;
using ImageProcessor.Plugins.WebP.Imaging.Formats;
using ImageProcessor;
using static System.Net.Mime.MediaTypeNames;
using System.Drawing;

namespace ImageWebPConverter
{
    class Program
    {
        static void Main(string[] args)
        {
            string sourceDirectory = @"C:\Users\micro\Downloads\Nouveau dossier";
            string destinationDirectory = @"C:\Users\micro\Downloads\Nouveau dossier";

            if (!Directory.Exists(destinationDirectory))
            {
                Directory.CreateDirectory(destinationDirectory);
            }

            string[] pngFiles = Directory.GetFiles(sourceDirectory, "*.png");
            string[] jpgFiles = Directory.GetFiles(sourceDirectory, "*.jpg");
            string[] allFiles = pngFiles.Concat(jpgFiles).ToArray();

            // Définir les tailles standard
            Size[] standardSizes = {
                    new Size(16, 16),
                    new Size(32, 32),
                    new Size(150, 150),
                    new Size(250, 150),
                    new Size(1200, 630),
                    new Size(800, 800),
                    new Size(1920, 1080),
                    new Size(512, 512),
                    new Size(600, 400),
                    new Size(750, 450)
            };

            foreach (string file in allFiles)
            {
                string fileName = Path.GetFileNameWithoutExtension(file);
                string fileExtension = Path.GetExtension(file).ToLower();

                foreach (Size size in standardSizes)
                {
                    string destinationPath = Path.Combine(destinationDirectory, $"{fileName}_{size.Width}x{size.Height}.webp");

                    using (var webPFileStream = new FileStream(destinationPath, FileMode.Create))
                    {
                        using (ImageFactory imageFactory = new ImageFactory(preserveExifData: false))
                        {
                            imageFactory.Load(File.OpenRead(file))
                                        .Resize(size)
                                        .Format(new WebPFormat())
                                        .Quality(75)
                                        .Save(webPFileStream);
                        }
                    }

                    Console.WriteLine($"Converted {fileName}{fileExtension} to {fileName}_{size.Width}x{size.Height}.webp");
                }
            }

            Console.WriteLine("Conversion completed.");
        }
    }
}

Explication du code

  1. Initialisation des répertoires : Le code commence par définir les répertoires source et de destination pour les images. Si le répertoire de destination n’existe pas, il sera créé.
  2. Récupération des fichiers image : Le code récupère tous les fichiers PNG et JPG du répertoire source.
  3. Définition des tailles standard : Un tableau de tailles standard est défini pour le redimensionnement des images.
  4. Boucle de conversion : Le code parcourt chaque fichier image et le convertit en différentes tailles en utilisant le format WebP, qui est connu pour sa haute qualité et sa petite taille de fichier.
  5. Qualité de l’image : Le paramètre de qualité est fixé à 75 pour équilibrer la qualité et la taille du fichier.
  6. Sauvegarde et confirmation : Chaque image redimensionnée est sauvegardée dans le répertoire de destination, et un message de confirmation est affiché dans la console

Conclusion

La conversion d’images en différents formats et tailles est une étape cruciale pour optimiser les performances de votre site web. Avec ce code simple en C#, vous pouvez automatiser ce processus et vous assurer que votre site offre la meilleure expérience utilisateur possible, tout en conservant une qualité d’image élevée.

N’hésitez pas à ajuster les tailles et les paramètres de qualité selon vos besoins spécifiques. Bon codage !

0 commentaires