Convertir le HTML d'une archive ZIP en JPG – Exemple C#

Dans cet article, nous créons un gestionnaire de messages personnalisé pour effectuer une tâche spécifique – convertir le code HTML d’une archive ZIP en JPG.

Il existe de nombreuses raisons pour lesquelles vous avez besoin de convertir HTML d’une archive ZIP au format JPG. Par exemple, si vous souhaitez convertir un document HTML(XHTML) contenant des ressources liées au format JPG, vous devez regrouper toutes ces ressources avec le document dans une seule archive ZIP et la convertir au format JPG. Aspose.HTML for .NET propose une fonctionnalité permettant de créer des gestionnaires de messages personnalisés pour travailler avec des archives ZIP.

Créer un gestionnaire de messages personnalisé

Aspose.HTML for .NET offre la possibilité de créer un gestionnaire de messages personnalisé. Concevons le gestionnaire personnalisé que nous pouvons utiliser pour travailler avec des archives ZIP. Procédez comme suit :

1. Utilisez l’espace de nommage nécessaire, à savoir Aspose.Html.Net. Cet espace de noms est présenté par des classes et des interfaces qui sont chargées de faciliter le traitement des réseaux.

2. Pour créer un gestionnaire de messages personnalisé, vous devez définir votre propre classe qui sera dérivée de la classe MessageHandler. La classe MessageHandler représente un type de base pour les gestionnaires de messages.

using Aspose.Html.Net;
...

	class ZipArchiveMessageHandler : MessageHandler
	{
	}

3. Initialiser une instance de la classe ZipArchiveMessageHandler et lui définir une propriété Filter.

4. Surchargez la méthode Invoke() de la classe MessageHandler pour mettre en œuvre le comportement du gestionnaire de messages personnalisé.

// Implement ZipArchiveMessageHandler in C#

// This message handler prints a message about start and finish processing request
class ZipArchiveMessageHandler : MessageHandler, IDisposable
{
    private string filePath;
    private Archive archive;

    // Initialize an instance of the ZipArchiveMessageHandler class
    public ZipArchiveMessageHandler(string path)
    {
        this.filePath = path;
        Filters.Add(new ProtocolMessageFilter("zip"));
    }

    // Override the Invoke() method
    public override void Invoke(INetworkOperationContext context)
    {
        // Call the GetFile() method that defines the logic in the Invoke() method
        byte[] buff = GetFile(context.Request.RequestUri.Pathname.TrimStart('/'));
        if (buff != null)
        {
            // Checking: if a resource is found in the archive, then return it as a Response
            context.Response = new ResponseMessage(HttpStatusCode.OK)
            {
                Content = new ByteArrayContent(buff)
            };
            context.Response.Headers.ContentType.MediaType = MimeType.FromFileExtension(context.Request.RequestUri.Pathname);
        }
        else
        {
            context.Response = new ResponseMessage(HttpStatusCode.NotFound);
        }

        // Call the next message handler
        Next(context);
    }


    byte[] GetFile(string path)
    {
        path = path.Replace(@"\", @"/");
        ArchiveEntry result = GetArchive().Entries.FirstOrDefault(x => path == x.Name);
        if (result != null)
        {
            using (Stream fs = result.Open())
            using (MemoryStream ms = new MemoryStream())
            {
                fs.CopyTo(ms);
                return ms.ToArray();
            }
        }
        return null;
    }

    Archive GetArchive()
    {
        return archive ??= new Archive(filePath);
    }

    public void Dispose()
    {
        archive?.Dispose();
    }
}

Examinons de plus près l’extrait de code :

• Le ZipArchiveMessageHandler personnalisé doit hériter de la classe MessageHandler de base. Il possède deux variables : l’archive et la représentation sous forme de chaîne de caractères du chemin vers l’archive. L’héritage de IDisposable est nécessaire pour fournir un mécanisme de libération déterministe des ressources non gérées.

• Le gestionnaire de message possède le concept de filtrage. Dans ce cas, un filtre de protocole (schéma) est ajouté, ce gestionnaire de message ne fonctionnera qu’avec le protocole "zip".

  Filtering messages by resource protocol is implemented using the ProtocolMessageFilter class. The ProtocolMessageFilter() constructor initializes a new instance of the ProtocolMessageFilter class. It takes the "zip" protocols as a parameter.

• La méthode Invoke() implémente le comportement du gestionnaire de message. Elle est appelée pour chaque gestionnaire dans le pipeline et prend un contexte comme paramètre. La méthode GetFile() définit la logique de la méthode Invoke(). Elle implémente la chaîne de tâches, après laquelle le gestionnaire Next(contexte) suivant est appelé.

  The GetFile() method realizes a search for data as a byte array in a zip archive based on Request and forms Response.

• le contexte fournit des informations contextuelles pour les services réseau, l’entité de l’opération lui est transmise et le résultat de l’opération est renvoyé. Dans Aspose.HTML, le contexte est réalisé par l’interface INetworkOperationContext qui possède deux propriétés (paramètres) – Request et Response.

Ajouter ZipArchiveMessageHandler au pipeline

Le concept clé du fonctionnement des gestionnaires de messages est leur enchaînement, et vous devez maintenant ajouter ZipArchiveMessageHandler dans le pipeline. Le constructeur Configuration() crée une instance de la classe Configuration. Une fois la configuration créée, les méthodes GetService<INetworkService>() et MessageHandlers.Add() sont invoquées. La méthode Add() prend en paramètre un objet zip et ajoute ZipArchiveMessageHandler à la fin de la collection des gestionnaires de messages.

// Convert HTML from a ZIP archive to JPG using C#

// Add this line before you try to use the 'IBM437' encoding
System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance);

// Prepare path to a source zip file
string documentPath = Path.Combine(DataDir, "test.zip");

// Prepare path for converted file saving
string savePath = Path.Combine(OutputDir, "zip-to-jpg.jpg");

// Create an instance of ZipArchiveMessageHandler
using ZipArchiveMessageHandler zip = new ZipArchiveMessageHandler(documentPath);

// Create an instance of the Configuration class
using Configuration configuration = new Configuration();

// Add ZipArchiveMessageHandler to the chain of existing message handlers
configuration
    .GetService<INetworkService>()
    .MessageHandlers.Add(zip);

// Initialize an HTML document with specified configuration
using HTMLDocument document = new HTMLDocument("zip:///test.html", configuration);

// Create an instance of Rendering Options
ImageRenderingOptions options = new ImageRenderingOptions()
{
    Format = ImageFormat.Jpeg
};

// Create an instance of Image Device
using ImageDevice device = new ImageDevice(options, savePath);

// Render ZIP to JPG
document.RenderTo(device);

Dans l’exemple, l’archive ZIP (test.zip) contient le document HTML (test.html) dans lequel toutes les ressources liées ont des chemins relatifs au document HTML.

Note: Le constructeur HTMLDocument(address, configuration) prend le chemin absolu vers l’archive ZIP. Mais toutes les ressources associées ont des chemins relatifs dans le document HTML et dans le code de l’exemple.

Pour plus d’informations sur la façon de convertir HTML en JPG en utilisant la méthode Renderto(device), veuillez lire l’article Fine-Tuning Converters.

Vous pouvez télécharger les exemples C# complets et les fichiers de données sur GitHub.