Aspose.HTML for .NET 24.2 – guardar HTML en una secuencia
Aspose.HTML for .NET 24.2
En la versión 24.2, la interfaz IOutputStorage quedó obsoleta, pero seguirá funcionando hasta que se lance la versión 24.5. Si utiliza versiones anteriores de Aspose.HTML for .NET, le recomendamos que actualice y migre a la nueva versión, ya que la versión 24.5 eliminará esta interfaz obsoleta.
| Deprecated | New |
|---|---|
| IOutputStorage Interface | ResourceHandler Class |
El documento HTML puede contener diferentes recursos como CSS, imágenes externas y archivos. En el artículo, consideraremos casos para guardar documentos HTML con recursos en un archivo Zip y en un flujo de memoria. Aspose.HTML for .NET continúa desarrollando y mejorando las formas de guardar HTML con todos los archivos vinculados. Aquí veremos ejemplos de cómo guardar archivos usando clases obsoletas y ofreceremos soluciones avanzadas para implementar nuevas clases.
Clase ResourceHandler frente a interfaz IOutputStorage
La clase
ResourceHandler permite a los desarrolladores implementar el método
HandleResource(), en el que usted mismo puede crear una secuencia y publicarla donde la necesite. El nuevo método agrega la capacidad de ver un “Recurso” y procesar más información sobre él. Por lo tanto, al adoptar la clase ResourceHandler, los desarrolladores pueden beneficiarse de un enfoque más ágil y expresivo para administrar recursos, lo que resulta en un código más limpio, más fácil de mantener y flexible al guardar documentos HTML.
Guarde HTML en un archivo Zip
Aquí, examinaremos el mismo ejemplo de cómo guardar el archivo
with-resources.html en un archivo Zip usando una interfaz IOutputStorage obsoleta y una nueva clase ResourceHandler.
Uso de IOutputStorage: 24.1.0 y versiones anteriores
La interfaz IOutputStorage era una interfaz básica que admitía la creación y gestión de flujos de salida. Puede implementar la interfaz IOutputStorage creando la clase ZipStorage para guardar HTML con recursos en un archivo Zip:
1using System.IO;
2using Aspose.Html;
3using Aspose.Html.Saving;
4using System.IO.Compression;
5...
6
7 // Prepare a path to a source HTML file
8 string inputPath = Path.Combine(DataDir, "with-resources.html");;
9
10 var dir = Directory.GetCurrentDirectory();
11
12 // Prepare a full path to an output Zip storage
13 string customArchivePath = Path.Combine(dir, "./../../../../tests-out/old/archive.zip");
14
15 // Load the HTML document
16 using (var doc = new HTMLDocument(inputPath))
17 {
18 // Initialize an instance of the ZipStorage class
19 using (var zipSrorage = new ZipStorage(customArchivePath))
20 {
21 // Save HTML with resources to a Zip archive
22 doc.Save(zipSrorage);
23 }
24 }El siguiente fragmento de código muestra la realización de IOutputStorage en la clase ZipStorage para demostrar cómo guardar un documento HTML con recursos en un archivo Zip.
1 internal class ZipStorage : IOutputStorage, IDisposable
2 {
3 private FileStream zipStream;
4 private ZipArchive archive;
5 private int streamsCounter;
6 private bool initialized;
7
8 public ZipStorage(string name)
9 {
10 DisposeArchive();
11 zipStream = new FileStream(name, FileMode.Create);
12 archive = new ZipArchive(zipStream, ZipArchiveMode.Update);
13 initialized = false;
14 }
15
16 public OutputStream CreateStream(OutputStreamContext context)
17 {
18 var zipUri = (streamsCounter++ == 0 ? Path.GetFileName(context.Uri) :
19 Path.Combine(Path.GetFileName(Path.GetDirectoryName(context.Uri)), Path.GetFileName(context.Uri)));
20 var samplePrefix = String.Empty;
21 if (initialized)
22 samplePrefix = "my_";
23 else
24 initialized = true;
25
26 var newStream = archive.CreateEntry(samplePrefix + zipUri).Open();
27 var outputStream = new OutputStream(newStream, "file:///" + samplePrefix + zipUri);
28 return outputStream;
29 }
30
31 public void ReleaseStream(OutputStream stream)
32 {
33 stream.Flush();
34 stream.Close();
35 }
36
37 private void DisposeArchive()
38 {
39 if (archive != null)
40 {
41 archive.Dispose();
42 archive = null;
43 }
44 if (zipStream != null)
45 {
46 zipStream.Dispose();
47 zipStream = null;
48 }
49 streamsCounter = 0;
50 }
51
52 public void Dispose()
53 {
54 DisposeArchive();
55 }
56 }Usando la nueva clase ResourceHandler – Desde la versión 24.2
La clase
ResourceHandler está destinada a la implementación de los clientes. El siguiente ejemplo de C# muestra cómo guardar un documento HTML con recursos en un archivo Zip usando la clase ZipResourceHandler de ResourceHandler:
1using System.IO;
2using Aspose.Html;
3using Aspose.Html.Saving;
4using Aspose.Html.Saving.ResourceHandlers;
5using System.IO.Compression;
6...
7
8 // Prepare a path to a source HTML file
9 string inputPath = Path.Combine(DataDir, "with-resources.html");
10
11 var dir = Directory.GetCurrentDirectory();
12
13 // Prepare a full path to an output zip storage
14 string customArchivePath = Path.Combine(dir, "./../../../../tests-out/new/archive.zip");
15
16 // Load the HTML document
17 using (var doc = new HTMLDocument(inputPath))
18 {
19 // Initialize an instance of the ZipResourceHandler class
20 using (var resourceHandler = new ZipResourceHandler(customArchivePath))
21 {
22 // Save HTML with resources to a Zip archive
23 doc.Save(resourceHandler);
24 }
25 }El siguiente fragmento de código muestra la realización de ResourceHandler en la clase ZipResourceHandler para demostrar cómo guardar un documento HTML con recursos en un archivo Zip. El método
HandleResource() de la clase ZipResourceHandler es responsable de manejar cada recurso durante el proceso de guardado al crear un archivo Zip:
1 internal class ZipResourceHandler : ResourceHandler, IDisposable
2 {
3 private FileStream zipStream;
4 private ZipArchive archive;
5 private int streamsCounter;
6 private bool initialized;
7
8 public ZipResourceHandler(string name)
9 {
10 DisposeArchive();
11 zipStream = new FileStream(name, FileMode.Create);
12 archive = new ZipArchive(zipStream, ZipArchiveMode.Update);
13 initialized = false;
14 }
15
16 public override void HandleResource(Resource resource, ResourceHandlingContext context)
17 {
18 var zipUri = (streamsCounter++ == 0
19 ? Path.GetFileName(resource.OriginalUrl.Href)
20 : Path.Combine(Path.GetFileName(Path.GetDirectoryName(resource.OriginalUrl.Href)),
21 Path.GetFileName(resource.OriginalUrl.Href)));
22 var samplePrefix = String.Empty;
23 if (initialized)
24 samplePrefix = "my_";
25 else
26 initialized = true;
27
28 using (var newStream = archive.CreateEntry(samplePrefix + zipUri).Open())
29 {
30 resource.WithOutputUrl(new Url("file:///" + samplePrefix + zipUri)).Save(newStream, context);
31 }
32 }
33
34 private void DisposeArchive()
35 {
36 if (archive != null)
37 {
38 archive.Dispose();
39 archive = null;
40 }
41
42 if (zipStream != null)
43 {
44 zipStream.Dispose();
45 zipStream = null;
46 }
47
48 streamsCounter = 0;
49 }
50
51 public void Dispose()
52 {
53 DisposeArchive();
54 }
55 }Guardar HTML en secuencias de memoria
Consideremos el ejemplo de C# de cómo guardar un archivo HTML con recursos vinculados a un flujo de memoria usando la interfaz obsoleta IOutputStorage y la nueva clase
ResourceHandler. El documento fuente
with-resources.html y los archivos vinculados están en el mismo directorio.
Uso de IOutputStorage: 24.1.0 y versiones anteriores
La implementación de la interfaz IOutputStorage permitió guardar HTML en flujos de memoria:
1using System.IO;
2using Aspose.Html;
3using Aspose.Html.Saving;
4using System.Collections.Generic;
5...
6
7 // Prepare a path to a source HTML file
8 string inputPath = Path.Combine(DataDir, "with-resources.html");
9
10 // Initialaze an HTML document
11 using (var doc = new HTMLDocument(inputPath))
12 {
13 // Create an instance of the MemoryOutputStorage class and save HTML to memory
14 var memoryStorage = new MemoryOutputStorage();
15 doc.Save(memoryStorage);
16 memoryStorage.PrintInfo();
17 }Después de ejecutar el ejemplo, se imprimirá el mensaje sobre el almacenamiento de memoria:
uri:memory:///with-resources.html, length:256uri:memory:///photo1.png, length:57438
El siguiente fragmento de código muestra la realización de IOutputStorage en la clase MemoryOutputStorage para demostrar cómo guardar un documento HTML en secuencias de memoria.
1 internal class MemoryOutputStorage : IOutputStorage
2 {
3 public List<Tuple<OutputStream, string>> Streams;
4
5 public MemoryOutputStorage()
6 {
7 Streams = new List<Tuple<OutputStream, string>>();
8 }
9
10 public OutputStream CreateStream(OutputStreamContext context)
11 {
12 var normalizedPath = new Url(context.Uri).Pathname;
13 var uri = new Url(Path.GetFileName(normalizedPath), "memory:///").Href;
14 var outputStream = new OutputStream(new MemoryStream(), uri);
15 Streams.Add(Tuple.Create(outputStream, uri));
16 return outputStream;
17 }
18
19 public void ReleaseStream(OutputStream stream)
20 {
21 stream.Flush();
22 }
23
24 public void PrintInfo()
25 {
26 foreach (var stream in Streams)
27 Console.WriteLine($"uri:{stream.Item2}, length:{stream.Item1.Length}");
28 }
29 }Usando la nueva clase ResourceHandler – Desde la versión 24.2
El siguiente fragmento de código muestra la realización de ResourceHandler en la clase MemoryResourceHandler para demostrar cómo guardar un documento HTML en flujos de memoria:
1using System.IO;
2using Aspose.Html;
3using Aspose.Html.Saving;
4using Aspose.Html.Saving.ResourceHandlers;
5using System.Collections.Generic;
6...
7
8 // Prepare a path to a source HTML file
9 string inputPath = Path.Combine(DataDir, "with-resources.html");
10
11 // Load the HTML document
12 using (var doc = new HTMLDocument(inputPath))
13 {
14 // Create an instance of the MemoryResourceHandler class and save HTML to memory
15 var resourceHandler = new MemoryResourceHandler();
16 doc.Save(resourceHandler);
17 resourceHandler.PrintInfo();
18 }En lugar de los métodos CreateStream() y ReleaseStream() implementados en la clase MemoryOutputStorage de la interfaz IOutputStorage, ahora hay un método
HandleResource() implementado en la clase MemoryResourceHandler de Clase ResourceHandler, en la que puedes crear una secuencia tú mismo y publicarla donde la necesites. El nuevo método agrega la capacidad de ver un “Recurso” y procesar más información sobre él:
1 internal class MemoryResourceHandler : ResourceHandler
2 {
3 public List<Tuple<Stream, Resource>> Streams;
4
5 public MemoryResourceHandler()
6 {
7 Streams = new List<Tuple<Stream, Resource>>();
8 }
9
10 public override void HandleResource(Resource resource, ResourceHandlingContext context)
11 {
12 var outputStream = new MemoryStream();
13 Streams.Add(Tuple.Create<Stream, Resource>(outputStream, resource));
14 resource
15 .WithOutputUrl(new Url(Path.GetFileName(resource.OriginalUrl.Pathname), "memory:///"))
16 .Save(outputStream, context);
17 }
18
19 public void PrintInfo()
20 {
21 foreach (var stream in Streams)
22 Console.WriteLine($"uri:{stream.Item2.OutputUrl}, length:{stream.Item1.Length}");
23 }
24 }Como puede ver, el nuevo enfoque opera directamente con objetos Resource, eliminando la necesidad de clases adicionales como OutputStream. Esto simplifica el código y hace que la interacción con los recursos sea más explícita y comprensible. Por lo tanto, la clase base ResourceHandler ofrece una forma más simplificada y expresiva de manejar recursos al guardar documentos HTML en flujos de memoria.
Después de ejecutar el ejemplo, se imprimirá el mensaje sobre el almacenamiento de memoria:
uri:memory:///with-resources.html, length:256uri:memory:///photo1.png, length:57438
Aspose.HTML ofrece Aplicaciones web HTML gratuitas que son una colección en línea de convertidores, fusiones, herramientas de SEO, generadores de código HTML, herramientas de URL y más. Las aplicaciones funcionan en cualquier sistema operativo con un navegador web y no requieren ninguna instalación de software adicional. Es una manera rápida y fácil de resolver de manera eficiente y efectiva sus tareas relacionadas con HTML.