Guardar documento HTML – ejemplos de C#

Después de descargar un archivo existente o crear un documento HTML desde cero, puede guardar los cambios utilizando uno de los métodos HTMLDocument.Save(). Existen métodos sobrecargados para guardar un documento en un archivo, URL o secuencias.

• La API proporciona el espacio de nombres Aspose.Html.Saving con las clases SaveOptions y ResourceHandlingOptions que le permiten configurar opciones para guardar operaciones.
• La API proporciona un espacio de nombres Aspose.Html.Saving.ResourceHandlers que contiene las clases ResourceHandler y FileSystemResourceHandler responsables de manejar los recursos.

Tenga en cuenta que tenemos dos conceptos diferentes para crear los archivos de salida:

• La primera concepción se basa en producir archivos tipo HTML como salida. SaveOptions como clase base para este enfoque ayuda a manejar el proceso de guardar recursos relacionados como scripts, estilos, imágenes, etc. La clase ResourceHandler es responsable de manejar los recursos. Está desarrollado para guardar contenido y recursos HTML en secuencias y proporciona métodos que le permiten controlar lo que se hará con el recurso.
• Como resultado, el segundo concepto podría usarse para crear una representación visual de HTML. La clase base para esta concepción es RenderingOptions; Tiene métodos especializados para especificar el tamaño de la página, los márgenes de la página, la resolución, los estilos de usuario, etc.

Este artículo solo describe cómo usar las clases SaveOptions y ResourceHandler. Para leer más sobre el mecanismo de renderizado, siga los artículos Renderizadores y Opciones de renderizado.

SaveOptions y ResourceHandlingOptions

SaveOptions es una clase base que le permite especificar opciones adicionales para guardar operaciones y ayuda a administrar los recursos vinculados. La propiedad ResourceHandlingOptions de la clase SaveOptions se utiliza para la configuración del manejo de recursos. La clase ResourceHandlingOptions representa opciones de manejo de recursos y la lista de las disponibles se muestra en la siguiente tabla:

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.

Guardar HTML

Una vez que haya terminado los cambios en HTML, es posible que desee guardar el documento. Puedes hacerlo usando uno de los métodos Save() de la clase HTMLDocument. El siguiente ejemplo es la forma más sencilla de guardar un archivo HTML:

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

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

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

En el ejemplo anterior, utilizamos el constructor HTMLDocument() para inicializar un documento HTML vacío. El método CreateTextNode(data) de la clase HTMLDocument crea un nodo de texto dada la cadena especificada. El método Save(path) guarda el documento en un archivo local especificado por la ruta.

El ejemplo anterior es bastante simple. Sin embargo, en aplicaciones de la vida real, a menudo se necesita control adicional sobre el proceso de guardado. Las siguientes secciones describen cómo utilizar las opciones de manejo de recursos o guardar su documento en diferentes formatos.

Guardar HTML en un archivo

El siguiente fragmento de código muestra cómo utilizar la propiedad ResourceHandlingOptions de la clase SaveOptions para administrar archivos vinculados a sus documentos.

// 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 (var document = new HTMLDocument(documentPath))
{
    // Create a save options instance
    var 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);
}

Guarde HTML en un almacenamiento del sistema de archivos local

El documento HTML puede contener diferentes recursos como CSS, imágenes y archivos externos. Aspose.HTML for .NET proporciona una forma de guardar HTML con todos los archivos vinculados: la clase ResourceHandler está desarrollada para guardar contenido HTML y recursos en secuencias. Esta clase es responsable de manejar los recursos y proporciona métodos que le permiten controlar lo que se hace con cada recurso.

Consideremos un ejemplo de cómo guardar HTML con recursos en un almacenamiento de archivos local especificado por el usuario. El documento fuente with-resources.html y su archivo de imagen vinculado están en el mismo directorio. El constructor FileSystemResourceHandler(customOutDir) toma una ruta que indica dónde se guardará el documento con recursos y crea un objeto FileSystemResourceHandler. El método Save(resourceHandler) toma este objeto y guarda HTML en el almacenamiento de salida.

// 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 (var doc = new HTMLDocument(inputPath))
{
    // Save HTML with resources
    doc.Save(new FileSystemResourceHandler(customOutDir));
}

Guarde HTML en un archivo Zip

Puede implementar ResourceHandler creando la clase ZipResourceHandler. Le permite crear un archivo estructurado y comprimido que contiene documentos HTML y recursos asociados, lo que lo hace adecuado para escenarios como el archivado y la optimización del almacenamiento. El método HandleResource() en la clase ZipResourceHandler sirve para personalizar el comportamiento de cómo se procesan y almacenan los recursos individuales en un archivo Zip.

En el siguiente ejemplo, la clase ZipResourceHandler se utiliza para guardar el documento with-resources.html junto con sus recursos vinculados en un archivo Zip:

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

var 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 (var doc = new HTMLDocument(inputPath))
{
    // Initialize an instance of the ZipResourceHandler class
    using (var resourceHandler = new ZipResourceHandler(customArchivePath))
    {
        // Save HTML with resources to a Zip archive
        doc.Save(resourceHandler);
    }
}

La clase ResourceHandler está destinada a la implementación del cliente. La clase ZipResourceHandler extiende la clase base ResourceHandler y proporciona una manera conveniente de administrar todo el proceso de manejo y almacenamiento de recursos vinculados con un documento HTML en un archivo Zip:

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)
    {
        var zipUri = (streamsCounter++ == 0
            ? Path.GetFileName(resource.OriginalUrl.Href)
            : Path.Combine(Path.GetFileName(Path.GetDirectoryName(resource.OriginalUrl.Href)),
                Path.GetFileName(resource.OriginalUrl.Href)));
        var samplePrefix = String.Empty;
        if (initialized)
            samplePrefix = "my_";
        else
            initialized = true;

        using (var 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();
    }
}

Guardar HTML en secuencias de memoria

La implementación de la clase ResourceHandler en la clase MemoryResourceHandler permite guardar HTML en flujos de memoria. El siguiente código muestra cómo utilizar la clase MemoryResourceHandler para almacenar un documento HTML en la memoria, recopilando e imprimiendo información sobre los recursos manejados.

1. Inicialice un documento HTML utilizando la ruta del archivo HTML especificada.
2. Cree una instancia de la clase MemoryResourceHandler. Esta clase está diseñada para capturar y almacenar recursos dentro de flujos de memoria durante el proceso de manejo de recursos.
3. Llame al método Save() del documento HTML y pásele la instancia MemoryResourceHandler como argumento. Esto asocia la lógica de manejo de recursos de MemoryResourceHandler con el proceso de guardar documentos HTML.
4. Utilice el método PrintInfo() de MemoryResourceHandler para imprimir información sobre los recursos manejados.

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

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

Después de ejecutar el ejemplo, se imprimirá el mensaje sobre el almacenamiento de memoria:

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

ResourceHandler es una clase base que admite la creación y gestión de flujos de salida. La clase MemoryResourceHandler le permite capturar y almacenar flujos de recursos en memoria, proporcionando una forma dinámica y flexible de manejar recursos sin guardarlos físicamente en el sistema de archivos. El siguiente fragmento de código muestra la realización de ResourceHandler en la clase MemoryResourceHandler:

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)
    {
        var 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 (var stream in Streams)
            Console.WriteLine($"uri:{stream.Item2.OutputUrl}, length:{stream.Item1.Length}");
    }
}

Guardar HTML en MHTML

En algunos casos, deberá guardar su página web como un solo archivo. El documento MHTML puede resultar útil y útil para este propósito, ya que es un archivo de página web y almacena todo dentro de sí mismo. La enumeración HTMLSaveFormat especifica el formato en el que se guarda el documento; pueden ser formatos HTML, MHTML y MD. El siguiente ejemplo muestra cómo utilizar el método Save(path, saveFormat) para guardar HTML en MHTML.

// 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 (var document = new HTMLDocument("save-to-mhtml.html"))
{
    // Save the document to MHTML format
    document.Save(savePath, HTMLSaveFormat.MHTML);
}

El archivo “save-to-mhtml.mht” guardado almacena HTML de los archivos “document.html” y “linked-file.html”.

Guardar HTML en Markdown

Markdown es un lenguaje de marcado con sintaxis de texto sin formato. Además del ejemplo de HTML a MHTML, puede utilizar HTMLSaveFormat para guardar HTML a MD. Por favor, eche un vistazo al siguiente ejemplo:

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

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

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

Para obtener más información sobre cómo utilizar HTML Converter, visite el artículo Convertir HTML a Markdown.

Guardar SVG

Por lo general, puede ver SVG como parte de un archivo HTML, se usa para representar los datos vectoriales en la página: imágenes, íconos, tablas, etc. Sin embargo, SVG también se puede extraer de la web. página y puede manipularla de forma similar al documento HTML.

Dado que SVGDocument y HTMLDocument se basan en el mismo estándar WHATWG DOM, todas las operaciones como cargar, leer, editar, convertir y guardar son similares para ambos documentos. Por lo tanto, todos los ejemplos en los que puede ver manipulación con HTMLDocument también son aplicables para SVGDocument.

Para guardar sus cambios, utilice lo siguiente:

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

// Prepare SVG code
var 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 (var document = new SVGDocument(code, "."))
{
    // Save the SVG file to a disk
    document.Save(documentPath);
}

Para obtener más información sobre el dibujo básico de SVG y el uso de API para el procesamiento y representación de documentos SVG, consulte la Documentación de Aspose.SVG for .NET.

Puede descargar los ejemplos completos y los archivos de datos desde GitHub.