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:
1// Save HTML to a file
2
3// Prepare an output path for a document saving
4string documentPath = Path.Combine(OutputDir, "save-to-file.html");
5
6// Initialize an empty HTML document
7using (HTMLDocument document = new HTMLDocument())
8{
9 // Create a text element and add it to the document
10 Text text = document.CreateTextNode("Hello, World!");
11 document.Body.AppendChild(text);
12
13 // Save the HTML document to the file on a disk
14 document.Save(documentPath);
15}
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.
1// Save HTML with a linked resources
2
3// Prepare an output path for an HTML document
4string documentPath = Path.Combine(OutputDir, "save-with-linked-file.html");
5
6// Prepare a simple HTML file with a linked document
7File.WriteAllText(documentPath, "<p>Hello, World!</p>" +
8 "<a href='linked.html'>linked file</a>");
9
10// Prepare a simple linked HTML file
11File.WriteAllText(Path.Combine(OutputDir, "linked.html"), "<p>Hello, linked file!</p>");
12
13// Load the "save-with-linked-file.html" into memory
14using (HTMLDocument document = new HTMLDocument(documentPath))
15{
16 // Create a save options instance
17 HTMLSaveOptions options = new HTMLSaveOptions();
18
19 // The following line with value '0' cuts off all other linked HTML-files while saving this instance
20 // If you remove this line or change value to the '1', the 'linked.html' file will be saved as well to the output folder
21 options.ResourceHandlingOptions.MaxHandlingDepth = 1;
22
23 // Save the document with the save options
24 document.Save(Path.Combine(OutputDir, "save-with-linked-file_out.html"), options);
25}
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.
1// Save HTML with resources to local storage
2
3// Prepare a path to a source HTML file
4string inputPath = Path.Combine(DataDir, "with-resources.html");
5
6// Prepare a full path to an output directory
7string customOutDir = Path.Combine(Directory.GetCurrentDirectory(), "./../../../../tests-out/saving/");
8
9// Load the HTML document from a file
10using (HTMLDocument doc = new HTMLDocument(inputPath))
11{
12 // Save HTML with resources
13 doc.Save(new FileSystemResourceHandler(customOutDir));
14}
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:
1// Save HTML with resources to a Zip archive
2
3// Prepare a path to a source HTML file
4string inputPath = Path.Combine(DataDir, "with-resources.html");
5
6string dir = Directory.GetCurrentDirectory();
7
8// Prepare a full path to an output zip storage
9string customArchivePath = Path.Combine(dir, "./../../../../tests-out/saving/archive.zip");
10
11// Load the HTML document
12using (HTMLDocument doc = new HTMLDocument(inputPath))
13{
14 // Initialize an instance of the ZipResourceHandler class
15 using (ZipResourceHandler resourceHandler = new ZipResourceHandler(customArchivePath))
16 {
17 // Save HTML with resources to a Zip archive
18 doc.Save(resourceHandler);
19 }
20}
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:
1// Custom resource handler to save HTML with resources into a ZIP archive
2
3internal class ZipResourceHandler : ResourceHandler, IDisposable
4{
5 private FileStream zipStream;
6 private ZipArchive archive;
7 private int streamsCounter;
8 private bool initialized;
9
10 public ZipResourceHandler(string name)
11 {
12 DisposeArchive();
13 zipStream = new FileStream(name, FileMode.Create);
14 archive = new ZipArchive(zipStream, ZipArchiveMode.Update);
15 initialized = false;
16 }
17
18 public override void HandleResource(Resource resource, ResourceHandlingContext context)
19 {
20 string zipUri = (streamsCounter++ == 0
21 ? Path.GetFileName(resource.OriginalUrl.Href)
22 : Path.Combine(Path.GetFileName(Path.GetDirectoryName(resource.OriginalUrl.Href)),
23 Path.GetFileName(resource.OriginalUrl.Href)));
24 string samplePrefix = String.Empty;
25 if (initialized)
26 samplePrefix = "my_";
27 else
28 initialized = true;
29
30 using (Stream newStream = archive.CreateEntry(samplePrefix + zipUri).Open())
31 {
32 resource.WithOutputUrl(new Url("file:///" + samplePrefix + zipUri)).Save(newStream, context);
33 }
34 }
35
36 private void DisposeArchive()
37 {
38 if (archive != null)
39 {
40 archive.Dispose();
41 archive = null;
42 }
43
44 if (zipStream != null)
45 {
46 zipStream.Dispose();
47 zipStream = null;
48 }
49
50 streamsCounter = 0;
51 }
52
53 public void Dispose()
54 {
55 DisposeArchive();
56 }
57}
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.
- Inicialice un documento HTML utilizando la ruta del archivo HTML especificada.
- 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. - Llame al método
Save()
del documento HTML y pásele la instanciaMemoryResourceHandler
como argumento. Esto asocia la lógica de manejo de recursos deMemoryResourceHandler
con el proceso de guardar documentos HTML. - Utilice el método
PrintInfo()
deMemoryResourceHandler
para imprimir información sobre los recursos manejados.
1// Save HTML with resources to memory streams
2
3// Prepare a path to a source HTML file
4string inputPath = Path.Combine(DataDir, "with-resources.html");
5
6// Load the HTML document
7using (HTMLDocument doc = new HTMLDocument(inputPath))
8{
9 // Create an instance of the MemoryResourceHandler class and save HTML to memory
10 MemoryResourceHandler resourceHandler = new MemoryResourceHandler();
11 doc.Save(resourceHandler);
12 resourceHandler.PrintInfo();
13}
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:
1// In-memory resource handler that captures and stores HTML resources as streams
2
3internal class MemoryResourceHandler : ResourceHandler
4{
5 public List<Tuple<Stream, Resource>> Streams;
6
7 public MemoryResourceHandler()
8 {
9 Streams = new List<Tuple<Stream, Resource>>();
10 }
11
12 public override void HandleResource(Resource resource, ResourceHandlingContext context)
13 {
14 MemoryStream outputStream = new MemoryStream();
15 Streams.Add(Tuple.Create<Stream, Resource>(outputStream, resource));
16 resource
17 .WithOutputUrl(new Url(Path.GetFileName(resource.OriginalUrl.Pathname), "memory:///"))
18 .Save(outputStream, context);
19 }
20
21 public void PrintInfo()
22 {
23 foreach (Tuple<Stream, Resource> stream in Streams)
24 Console.WriteLine($"uri:{stream.Item2.OutputUrl}, length:{stream.Item1.Length}");
25 }
26}
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.
1// Save HTML as MHTML
2
3// Prepare an output path for a document saving
4string savePath = Path.Combine(OutputDir, "save-to-mhtml.mht");
5
6// Prepare a simple HTML file with a linked document
7File.WriteAllText("save-to-mhtml.html", "<p>Hello, World!</p>" +
8 "<a href='linked-file.html'>linked file</a>");
9
10// Prepare a simple linked HTML file
11File.WriteAllText("linked-file.html", "<p>Hello, linked file!</p>");
12
13// Load the "save-to-mhtml.html" into memory
14using (HTMLDocument document = new HTMLDocument("save-to-mhtml.html"))
15{
16 // Save the document to MHTML format
17 document.Save(savePath, HTMLSaveFormat.MHTML);
18}
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:
1// Save HTML as Markdown
2
3// Prepare an output path for a document saving
4string documentPath = Path.Combine(OutputDir, "save-html-to-markdown.md");
5
6// Prepare HTML code
7string html_code = "<H2>Hello, World!</H2>";
8
9// Initialize a document from a string variable
10using (HTMLDocument document = new HTMLDocument(html_code, "."))
11{
12 // Save the document as a Markdown file
13 document.Save(documentPath, HTMLSaveFormat.Markdown);
14}
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:
1// Save HTML as SVG
2
3// Prepare an output path for a document saving
4string documentPath = Path.Combine(OutputDir, "save-html-to-svg.svg");
5
6// Prepare SVG code
7string code = @"
8 <svg xmlns='http://www.w3.org/2000/svg' height='200' width='300'>
9 <g fill='none' stroke-width= '10' stroke-dasharray='30 10'>
10 <path stroke='red' d='M 25 40 l 215 0' />
11 <path stroke='black' d='M 35 80 l 215 0' />
12 <path stroke='blue' d='M 45 120 l 215 0' />
13 </g>
14 </svg>";
15
16// Initialize an SVG instance from the content string
17using (SVGDocument document = new SVGDocument(code, "."))
18{
19 // Save the SVG file to a disk
20 document.Save(documentPath);
21}
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.