Enregistrer un document HTML – Exemples C#

Après avoir téléchargé un fichier existant ou créé un document HTML à partir de zéro, vous pouvez enregistrer les modifications à l’aide de l’une des méthodes HTMLDocument.Save(). Il existe des méthodes surchargées pour enregistrer un document dans un fichier, une URL ou des flux.

• L’API fournit l’espace de noms Aspose.Html.Saving avec les classes SaveOptions et ResourceHandlingOptions qui vous permettent de définir des options pour les opérations d’enregistrement.
• L’API fournit l’espace de noms Aspose.Html.Saving.ResourceHandlers qui contient les classes ResourceHandler et FileSystemResourceHandler responsables de la gestion des ressources.

Veuillez noter que nous avons deux concepts différents pour la création des fichiers de sortie :

• La première conception est basée sur la production de fichiers HTML en sortie. La classe SaveOptions, classe de base de cette approche, permet de gérer le processus d’enregistrement des ressources connexes telles que les scripts, les styles, les images, etc. La classe ResourceHandler est responsable de la gestion des ressources. Elle est développée pour enregistrer le contenu HTML et les ressources dans des flux et fournit des méthodes qui vous permettent de contrôler ce qui sera fait avec la ressource.
• Le second concept pourrait être utilisé pour créer une représentation visuelle du HTML en tant que résultat. La classe de base pour cette conception est RenderingOptions ; elle possède des méthodes spécialisées pour spécifier la taille de la page, les marges de la page, la résolution, les styles de l’utilisateur, etc.

Cet article ne décrit que l’utilisation des classes SaveOptions et ResourceHandler. Pour en savoir plus sur le mécanisme de rendu, veuillez consulter les articles Renderers et Rendering Options.

Options de sauvegarde et options de gestion des ressources

La classe SaveOptions est une classe de base qui vous permet de spécifier des options supplémentaires pour les opérations d’enregistrement et vous aide à gérer les ressources liées. La propriété ResourceHandlingOptions de la classe SaveOptions est utilisée pour la configuration de la gestion des ressources. La classe ResourceHandlingOptions représente les options de gestion des ressources et la liste des options disponibles est présentée dans le tableau suivant :

Option	Description
UrlRestriction	Applies restrictions to the host or folders where resources are located.
MaxHandlingDepth	If you need to save not the only specified HTML document, but also the linked HTML pages, this option gives you the ability to control the depth of the linked pages that should be saved.
JavaScript	This option specifies how do we need to treat the JavaScript files: it could be saved as a separated linked file, embed into HTML file or even be ignored.
Default	This option specifies behavior for other than JavaScript files. Gets or sets an enum, which represents the default way of resource handling. Currently, Save, Ignore, and Embed values are supported. The default value is Save.

Enregistrer HTML

Une fois que vous avez terminé vos modifications en HTML, vous pouvez enregistrer le document. Vous pouvez le faire en utilisant l’une des méthodes Save() de la classe HTMLDocument. L’exemple suivant est la manière la plus simple de sauvegarder un fichier HTML :

// Save HTML to a file using C#

// Prepare an output path for a document saving
string documentPath = Path.Combine(OutputDir, "save-to-file.html");

// Initialize an empty HTML document
using (HTMLDocument document = new HTMLDocument())
{
    // Create a text element and add it to the document
    Text text = document.CreateTextNode("Hello, World!");
    document.Body.AppendChild(text);

    // Save the HTML document to the file on a disk
    document.Save(documentPath);
}

Dans l’exemple ci-dessus, nous utilisons le constructeur HTMLDocument() pour initialiser un document HTML vide. La méthode CreateTextNode(data) de la classe HTMLDocument crée un nœud de texte à partir de la chaîne spécifiée. La méthode Save(path) enregistre le document dans un fichier local spécifié par path.

L’exemple ci-dessus est assez simple. Cependant, dans les applications réelles, vous avez souvent besoin d’un contrôle supplémentaire sur le processus d’enregistrement. Les sections suivantes décrivent comment utiliser les options de gestion des ressources ou enregistrer votre document dans les différents formats.

Enregistrer HTML dans un fichier

L’extrait de code suivant montre comment utiliser la propriété ResourceHandlingOptions de la classe SaveOptions pour gérer les liens vers vos fichiers de documents.

// Save HTML with a linked resources using C#

// Prepare an output path for an HTML document 
string documentPath = Path.Combine(OutputDir, "save-with-linked-file.html");

// Prepare a simple HTML file with a linked document
File.WriteAllText(documentPath, "<p>Hello, World!</p>" +
                                "<a href='linked.html'>linked file</a>");

// Prepare a simple linked HTML file
File.WriteAllText(Path.Combine(OutputDir, "linked.html"), "<p>Hello, linked file!</p>");

// Load the "save-with-linked-file.html" into memory
using (HTMLDocument document = new HTMLDocument(documentPath))
{
    // Create a save options instance
    HTMLSaveOptions options = new HTMLSaveOptions();

    // The following line with value '0' cuts off all other linked HTML-files while saving this instance
    // If you remove this line or change value to the '1', the 'linked.html' file will be saved as well to the output folder
    options.ResourceHandlingOptions.MaxHandlingDepth = 1;

    // Save the document with the save options
    document.Save(Path.Combine(OutputDir, "save-with-linked-file_out.html"), options);
}

Enregistrer HTML dans un système de fichiers local

Le document HTML peut contenir différentes ressources telles que des feuilles de style CSS, des images et des fichiers externes. Aspose.HTML for .NET fournit un moyen d’enregistrer le document HTML avec tous les fichiers liés – la classe ResourceHandler est développée pour enregistrer le contenu HTML et les ressources dans des flux. Cette classe est responsable de la gestion des ressources et fournit des méthodes qui vous permettent de contrôler ce qui est fait avec chaque ressource.

Prenons un exemple d’enregistrement de HTML avec ressources dans un fichier local spécifié par l’utilisateur. Le document source with-resources.html et son fichier image lié se trouvent dans le même répertoire. Le constructeur FileSystemResourceHandler(customOutDir) prend un chemin indiquant où le document avec ressources sera sauvegardé et crée un objet FileSystemResourceHandler. La méthode Save(resourceHandler) prend cet objet et enregistre le HTML dans le stockage de sortie.

// Save HTML with resources to local storage using C#

// Prepare a path to a source HTML file
string inputPath = Path.Combine(DataDir, "with-resources.html");

// Prepare a full path to an output directory 
string customOutDir = Path.Combine(Directory.GetCurrentDirectory(), "./../../../../tests-out/saving/");

// Load the HTML document from a file
using (HTMLDocument doc = new HTMLDocument(inputPath))
{
    // Save HTML with resources
    doc.Save(new FileSystemResourceHandler(customOutDir));
}

Enregistrer HTML dans une archive Zip

Vous pouvez mettre en œuvre le ResourceHandler en créant la classe ZipResourceHandler. Elle vous permet de créer une archive structurée et compressée contenant des documents HTML et des ressources associées, ce qui convient à des scénarios tels que l’archivage et l’optimisation du stockage. La méthode HandleResource() de la classe ZipResourceHandler permet de personnaliser la manière dont les ressources individuelles sont traitées et stockées dans une archive Zip.

Dans l’exemple suivant, la classe ZipResourceHandler est utilisée pour enregistrer le document with-resources.html avec ses ressources liées dans une archive Zip :

// Save an HTML document with all linked resources into a ZIP archive using C#

// Prepare a path to a source HTML file 
string inputPath = Path.Combine(DataDir, "with-resources.html");

string dir = Directory.GetCurrentDirectory();

// Prepare a full path to an output zip storage
string customArchivePath = Path.Combine(dir, "./../../../../tests-out/saving/archive.zip");

// Load the HTML document 
using (HTMLDocument doc = new HTMLDocument(inputPath))
{
    // Initialize an instance of the ZipResourceHandler class
    using (ZipResourceHandler resourceHandler = new ZipResourceHandler(customArchivePath))
    {
        // Save HTML with resources to a Zip archive
        doc.Save(resourceHandler);
    }
}

La classe ResourceHandler est destinée à être implémentée par le client. La classe ZipResourceHandler étend la classe de base ResourceHandler et fournit un moyen pratique de gérer l’ensemble du processus de manipulation et de stockage des ressources liées à un document HTML dans une archive Zip :

// Custom resource handler to save HTML with resources into a ZIP archive

internal class ZipResourceHandler : ResourceHandler, IDisposable
{
    private FileStream zipStream;
    private ZipArchive archive;
    private int streamsCounter;
    private bool initialized;

    public ZipResourceHandler(string name)
    {
        DisposeArchive();
        zipStream = new FileStream(name, FileMode.Create);
        archive = new ZipArchive(zipStream, ZipArchiveMode.Update);
        initialized = false;
    }

    public override void HandleResource(Resource resource, ResourceHandlingContext context)
    {
        string zipUri = (streamsCounter++ == 0
            ? Path.GetFileName(resource.OriginalUrl.Href)
            : Path.Combine(Path.GetFileName(Path.GetDirectoryName(resource.OriginalUrl.Href)),
                Path.GetFileName(resource.OriginalUrl.Href)));
        string samplePrefix = String.Empty;
        if (initialized)
            samplePrefix = "my_";
        else
            initialized = true;

        using (Stream newStream = archive.CreateEntry(samplePrefix + zipUri).Open())
        {
            resource.WithOutputUrl(new Url("file:///" + samplePrefix + zipUri)).Save(newStream, context);
        }
    }

    private void DisposeArchive()
    {
        if (archive != null)
        {
            archive.Dispose();
            archive = null;
        }

        if (zipStream != null)
        {
            zipStream.Dispose();
            zipStream = null;
        }

        streamsCounter = 0;
    }

    public void Dispose()
    {
        DisposeArchive();
    }
}

Enregistrer HTML dans des flux de mémoire

L’implémentation de la classe ResourceHandler dans la classe MemoryResourceHandler permet de sauvegarder du HTML dans des flux de mémoire. Le code suivant montre comment utiliser la classe MemoryResourceHandler pour stocker un document HTML en mémoire, en collectant et en imprimant des informations sur les ressources manipulées.

1. Initialise un document HTML en utilisant le chemin d’accès au fichier HTML spécifié.
2. Créer une instance de la classe MemoryResourceHandler. Cette classe est conçue pour capturer et stocker les ressources dans les flux de mémoire pendant le processus de traitement des ressources.
3. Appeler la méthode Save() du document HTML et lui passer l’instance MemoryResourceHandler comme argument. Cela permet d’associer la logique de gestion des ressources du MemoryResourceHandler au processus d’enregistrement du document HTML.
4. Utilisez la méthode PrintInfo() du MemoryResourceHandler pour imprimer des informations sur les ressources manipulées.

// Save HTML with resources to memory streams using C#

// Prepare a path to a source HTML file 
string inputPath = Path.Combine(DataDir, "with-resources.html");

// Load the HTML document 
using (HTMLDocument doc = new HTMLDocument(inputPath))
{
    // Create an instance of the MemoryResourceHandler class and save HTML to memory
    MemoryResourceHandler resourceHandler = new MemoryResourceHandler();
    doc.Save(resourceHandler);
    resourceHandler.PrintInfo();
}

Après l’exécution de l’exemple, le message relatif à la mémoire est imprimé :

uri:memory:///with-resources.html, length:256
uri:memory:///photo1.png, length:57438

La classe ResourceHandler est une classe de base qui prend en charge la création et la gestion des flux de sortie. La classe MemoryResourceHandler vous permet de capturer et de stocker des ressources dans des flux en mémoire, ce qui constitue un moyen dynamique et flexible de gérer des ressources sans les enregistrer physiquement dans le système de fichiers. L’extrait de code suivant montre la réalisation du ResourceHandler dans la classe MemoryResourceHandler :

// In-memory resource handler that captures and stores HTML resources as streams

internal class MemoryResourceHandler : ResourceHandler
{
    public List<Tuple<Stream, Resource>> Streams;

    public MemoryResourceHandler()
    {
        Streams = new List<Tuple<Stream, Resource>>();
    }

    public override void HandleResource(Resource resource, ResourceHandlingContext context)
    {
        MemoryStream outputStream = new MemoryStream();
        Streams.Add(Tuple.Create<Stream, Resource>(outputStream, resource));
        resource
            .WithOutputUrl(new Url(Path.GetFileName(resource.OriginalUrl.Pathname), "memory:///"))
            .Save(outputStream, context);
    }

    public void PrintInfo()
    {
        foreach (Tuple<Stream, Resource> stream in Streams)
            Console.WriteLine($"uri:{stream.Item2.OutputUrl}, length:{stream.Item1.Length}");
    }
}

Enregistrer HTML en MHTML

Dans certains cas, vous devez enregistrer votre page web sous la forme d’un fichier unique. le document MHTML peut s’avérer pratique et utile à cette fin, car il s’agit d’une archive de page web qui stocke tout à l’intérieur d’elle-même. L’énumération HTMLSaveFormat spécifie le format dans lequel le document est enregistré. Il peut s’agir des formats HTML, MHTML et MD. L’exemple ci-dessous montre comment utiliser la méthode Save(path, saveFormat) pour l’enregistrement HTML vers MHTML.

// Save HTML as MHTML using C#

// Prepare an output path for a document saving
string savePath = Path.Combine(OutputDir, "save-to-mhtml.mht");

// Prepare a simple HTML file with a linked document
File.WriteAllText("save-to-mhtml.html", "<p>Hello, World!</p>" +
                                        "<a href='linked-file.html'>linked file</a>");

// Prepare a simple linked HTML file
File.WriteAllText("linked-file.html", "<p>Hello, linked file!</p>");

// Load the "save-to-mhtml.html" into memory
using (HTMLDocument document = new HTMLDocument("save-to-mhtml.html"))
{
    // Save the document to MHTML format
    document.Save(savePath, HTMLSaveFormat.MHTML);
}

Le fichier “save-to-mhtml.mht” enregistré stocke le code HTML des fichiers “document.html” et “linked-file.html”.

Enregistrer HTML en Markdown

Markdown est un langage de balisage avec une syntaxe de texte brut. Comme pour l’exemple HTML vers MHTML, vous pouvez utiliser le HTMLSaveFormat pour l’enregistrement HTML vers MD. Jetez un oeil à l’exemple suivant :

// Save HTML as Markdown using C#

// Prepare an output path for a document saving
string documentPath = Path.Combine(OutputDir, "save-html-to-markdown.md");

// Prepare HTML code
string html_code = "<H2>Hello, World!</H2>";

// Initialize a document from a string variable
using (HTMLDocument document = new HTMLDocument(html_code, "."))
{
    // Save the document as a Markdown file
    document.Save(documentPath, HTMLSaveFormat.Markdown);
}

Pour plus d’informations sur l’utilisation de HTML Converter, veuillez consulter l’article Convertir HTML en Markdown.

Enregistrer SVG

Habituellement, vous pouvez voir SVG dans un fichier HTML, il est utilisé pour représenter les données vectorielles sur la page : images, icônes, tableaux, etc. Cependant, le SVG peut également être extrait de la page web et vous pouvez le manipuler de la même manière que le document HTML.

Puisque SVGDocument et HTMLDocument sont basés sur le même standard WHATWG DOM, toutes les opérations telles que le chargement, la lecture, l’édition, la conversion et l’enregistrement sont similaires pour les deux documents. Ainsi, tous les exemples de manipulation du document HTML s’appliquent également au document SVG.

Pour enregistrer vos modifications, procédez comme suit :

// Save HTML as SVG using C#

// Prepare an output path for a document saving
string documentPath = Path.Combine(OutputDir, "save-html-to-svg.svg");

// Prepare SVG code
string code = @"
    <svg xmlns='http://www.w3.org/2000/svg' height='200' width='300'>
        <g fill='none' stroke-width= '10' stroke-dasharray='30 10'>
            <path stroke='red' d='M 25 40 l 215 0' />
            <path stroke='black' d='M 35 80 l 215 0' />
            <path stroke='blue' d='M 45 120 l 215 0' />
        </g>
    </svg>";

// Initialize an SVG instance from the content string
using (SVGDocument document = new SVGDocument(code, "."))
{
    // Save the SVG file to a disk
    document.Save(documentPath);
}

Pour plus d’informations sur le dessin de base SVG et l’utilisation de l’API pour le traitement et le rendu des documents SVG, voir Aspose.SVG for .NET Documentation.

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