Convert HTML from ZIP archive to JPG – C# example
In this article, we create a custom Message Handler to do a specific task – convert HTML from ZIP archive to JPG.
You can download the complete C# examples and data files from GitHub.
There are many reasons why would you require to convert HTML from ZIP archive to JPG format. For example, if you want to convert an HTML(XHTML) document containing linked resources to JPG, you should pack all these resources along with the document into a single ZIP archive and convert it to JPG. Aspose.HTML for .NET provides functionality for creating custom message handlers for working with ZIP archives.
Create a Custom Message Handler
Aspose.HTML for .NET offers functionality for a custom message handler creating. Let’s design the custom handler that we can use to work with ZIP archives. Take the following steps:
Use the necessary Namespace, which is the Aspose.Html.Net. This Namespace is presented by classes and interfaces which are responsible for helping easy network processing.
To create a custom Message Handler, you need to define your own class that will be derived from the MessageHandler class. The MessageHandler class represents a base type for message handlers.
1using Aspose.Html.Net;
2...
3
4 class ZipArchiveMessageHandler : MessageHandler
5 {
6 }
Initialize an instance of the ZipArchiveMessageHandler class and define a Filter property for it.
Override the Invoke() method of the MessageHandler class to implement the custom message handler behaviour.
1using System.Net;
2using Aspose.Html;
3using Aspose.Html.Net;
4using Aspose.Html.Net.MessageFilters;
5using Aspose.Zip;
6...
7
8 // Define ZipArchiveMessageHandler class that is derived from the MessageHandler class
9 class ZipArchiveMessageHandler : MessageHandler, IDisposable
10 {
11 private string filePath;
12 private Archive archive;
13
14 // Initialize an instance of the ZipArchiveMessageHandler class
15 public ZipArchiveMessageHandler(string path)
16 {
17 this.filePath = path;
18 Filters.Add(new ProtocolMessageFilter("zip"));
19 }
20
21 // Override the Invoke() method
22 public override void Invoke(INetworkOperationContext context)
23 {
24 // Call the GetFile() method that defines the logic in the Invoke() method
25 var buff = GetFile(context.Request.RequestUri.Pathname.TrimStart('/'));
26 if (buff != null)
27 {
28 // Checking: if a resource is found in the archive, then return it as a Response
29 context.Response = new ResponseMessage(HttpStatusCode.OK)
30 {
31 Content = new ByteArrayContent(buff)
32 };
33 context.Response.Headers.ContentType.MediaType = MimeType.FromFileExtension(context.Request.RequestUri.Pathname);
34 }
35 else
36 {
37 context.Response = new ResponseMessage(HttpStatusCode.NotFound);
38 }
39
40 // Call the next message handler in the chain
41 Next(context);
42 }
43 }
Let’s consider closer the code snippet:
The custom ZipArchiveMessageHandler needs to inherit from the base MessageHandler class. It has two variables: the archive and the string representation of the path to the archive. Inheriting from IDisposable is necessary to provide a mechanism for the deterministic release of unmanaged resources.
The message handler has the concept of filtering. In this case, a protocol (schema) filter is added, this message handler will only work with the
"zip"
protocol.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.The Invoke() method implements the message handler behaviour. It is called for each handler in the pipeline and takes a
context
as a parameter. The GetFile() method defines the logic in the Invoke() method. It implements the chain of duties, after which the next Next(context
) handler is called.The GetFile() method realizes a search for data as a byte array in a zip archive based on Request and forms Response.
context
provides contextual information for network services, the entity of the operation is passed through it, and the result of the operation is returned. In Aspose.HTML, thecontext
is realized by INetworkOperationContext interface that has two properties (parameters) – Request and Response.
Define the GetFile(), GetArchive(), and Dispose() Methods
1using System.IO;
2using Aspose.Zip;
3...
4
5 byte[] GetFile(string path)
6 {
7 path = path.Replace(@"\", @"/");
8 var result = GetArchive().Entries.FirstOrDefault(x => path == x.Name);
9 if (result != null)
10 {
11 using (var fs = result.Open())
12 using (MemoryStream ms = new MemoryStream())
13 {
14 fs.CopyTo(ms);
15 return ms.ToArray();
16 }
17 }
18 return null;
19 }
20
21 Archive GetArchive()
22 {
23 return archive ??= new Archive(filePath);
24 }
25
26 public void Dispose()
27 {
28 archive?.Dispose();
29 }
Add ZipArchiveMessageHandler to the Pipeline
The key concept of message handlers work is chaining them together, and you would now need to add ZipArchiveMessageHandler in the pipeline. The Configuration() constructor creates an instance of the
Configuration class. After the configuration is created, the GetService<INetworkService>(), and MessageHandlers.Add() methods are invoked. The Add() method takes a zip
object as a parameter and appends ZipArchiveMessageHandler to the end of the message handlers’ collection.
1using System;
2using Aspose.Html;
3using Aspose.Html.Net;
4using Aspose.Html.Rendering.Image;
5using Aspose.Html.Services;
6...
7
8 // Prepare path to a source zip file
9 string documentPath = Path.Combine(DataDir, "test.zip");
10
11 // Prepare path for converted file saving
12 string savePath = Path.Combine(OutputDir, "zip-to-jpg.jpg");
13
14 // Create an instance of ZipArchiveMessageHandler
15 using var zip = new ZipArchiveMessageHandler(documentPath);
16
17 // Create an instance of the Configuration class
18 using var configuration = new Configuration();
19
20 // Add ZipArchiveMessageHandler to the chain of existing message handlers
21 configuration
22 .GetService<INetworkService>()
23 .MessageHandlers.Add(zip);
24
25 // Initialize an HTML document with specified configuration
26 using var document = new HTMLDocument("zip:///test.html", configuration);
27
28 // Create an instance of Rendering Options
29 var options = new ImageRenderingOptions()
30 {
31 Format = ImageFormat.Jpeg
32 };
33
34 // Create an instance of Image Device
35 using var device = new ImageDevice(options, savePath);
36
37 // Render HTML to JPG
38 document.RenderTo(device);
In the example, the ZIP archive (test.zip) has the HTML document (test.html) in which all related resources have paths relative to the HTML document.
Note: The
HTMLDocument(address, configuration
) constructor takes the absolute path to the ZIP archive. But all related resources have relative paths in the HTML document and in the example’s code.
For more information on how to convert HTML to JPG using
Renderto(device
) method, please read the
Fine-Tuning Converters article.
You can download the complete C# examples and data files from GitHub.