Convert HTML from ZIP Archive to JPG in C#

To convert HTML from a ZIP archive to JPG in C#, create a custom MessageHandler that resolves zip resources, add it to INetworkService.MessageHandlers, open the packaged HTML document, and render it to a raster image.

When an HTML or XHTML document references images, stylesheets, scripts, or fonts, keeping the document and resources in one ZIP archive makes the input package portable. Aspose.HTML for .NET can process that package through a custom message handler and render the final document to JPG.

Create a Custom Message Handler

Aspose.HTML for .NET supports custom message handlers for controlling resource loading. In this article, the handler reads ZIP archive entries when the document requests resources through the zip protocol.

Take the following steps:

1. Use the Aspose.Html.Net namespace, which contains networking classes and interfaces.
2. Define a ZipArchiveMessageHandler class derived from MessageHandler.
3. Configure the handler so it processes only ZIP-based resource requests.

using Aspose.Html.Net;
...

	class ZipArchiveMessageHandler : MessageHandler
	{
	}

After the class is declared:

4. Initialize an instance of the ZipArchiveMessageHandler class and define a Filter property for it.
5. Override the Invoke() method of the MessageHandler class to implement the custom message handler behavior.

// Implement ZipArchiveMessageHandler in C#

// This message handler prints a message about start and finish processing request
class ZipArchiveMessageHandler : MessageHandler, IDisposable
{
    private string filePath;
    private Archive archive;

    // Initialize an instance of the ZipArchiveMessageHandler class
    public ZipArchiveMessageHandler(string path)
    {
        this.filePath = path;
        Filters.Add(new ProtocolMessageFilter("zip"));
    }

    // Override the Invoke() method
    public override void Invoke(INetworkOperationContext context)
    {
        // Call the GetFile() method that defines the logic in the Invoke() method
        byte[] buff = GetFile(context.Request.RequestUri.Pathname.TrimStart('/'));
        if (buff != null)
        {
            // Checking: if a resource is found in the archive, then return it as a Response
            context.Response = new ResponseMessage(HttpStatusCode.OK)
            {
                Content = new ByteArrayContent(buff)
            };
            context.Response.Headers.ContentType.MediaType = MimeType.FromFileExtension(context.Request.RequestUri.Pathname);
        }
        else
        {
            context.Response = new ResponseMessage(HttpStatusCode.NotFound);
        }

        // Call the next message handler
        Next(context);
    }


    byte[] GetFile(string path)
    {
        path = path.Replace(@"\", @"/");
        ArchiveEntry result = GetArchive().Entries.FirstOrDefault(x => path == x.Name);
        if (result != null)
        {
            using (Stream fs = result.Open())
            using (MemoryStream ms = new MemoryStream())
            {
                fs.CopyTo(ms);
                return ms.ToArray();
            }
        }
        return null;
    }

    Archive GetArchive()
    {
        return archive ??= new Archive(filePath);
    }

    public void Dispose()
    {
        archive?.Dispose();
    }
}

The handler implementation includes these parts:

• ZipArchiveMessageHandler inherits from the base MessageHandler class and stores the archive and the string representation of the path to the archive. Inheriting from IDisposable provides a mechanism for deterministic release of unmanaged resources.

• The handler uses a protocol filter, so it works only 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 behavior. It is called for each handler in the pipeline and takes context as a parameter. The GetFile() method defines the resource lookup logic and then the handler can call Next(context).

  The GetFile() method searches for data as a byte array in the ZIP archive based on Request and then forms Response.

• context provides contextual information for network services. In Aspose.HTML, it is represented by the INetworkOperationContext interface, which exposes Request and Response properties.

Add ZipArchiveMessageHandler to the Pipeline

Message handlers work as a chain. After the handler is created, add ZipArchiveMessageHandler to the pipeline used by the document configuration. The Configuration constructor creates a configuration object; then GetService<INetworkService>() and MessageHandlers.Add() are used to append the zip handler.

To convert HTML from a ZIP archive to JPG:

1. Create a Configuration object.
2. Add the ZipArchiveMessageHandler instance to INetworkService.MessageHandlers.
3. Open the HTML document from the ZIP archive with HTMLDocument(address, configuration).
4. Configure image output for JPG rendering.
5. Render the document to a .jpg file.

// Convert HTML from a ZIP archive to JPG using C#

// Add this line before you try to use the 'IBM437' encoding
System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance);

// Prepare path to a source zip file
string documentPath = Path.Combine(DataDir, "test.zip");

// Prepare path for converted file saving
string savePath = Path.Combine(OutputDir, "zip-to-jpg.jpg");

// Create an instance of ZipArchiveMessageHandler
using ZipArchiveMessageHandler zip = new ZipArchiveMessageHandler(documentPath);

// Create an instance of the Configuration class
using Configuration configuration = new Configuration();

// Add ZipArchiveMessageHandler to the chain of existing message handlers
configuration
    .GetService<INetworkService>()
    .MessageHandlers.Add(zip);

// Initialize an HTML document with specified configuration
using HTMLDocument document = new HTMLDocument("zip:///test.html", configuration);

// Create an instance of Rendering Options
ImageRenderingOptions options = new ImageRenderingOptions()
{
    Format = ImageFormat.Jpeg
};

// Create an instance of Image Device
using ImageDevice device = new ImageDevice(options, savePath);

// Render ZIP to JPG
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. Related resources can still use paths relative to the HTML document inside the archive, as shown in the example.

For more information about rendering settings, see Fine-Tuning Converters and the RenderTo(device) method.

You can download the complete C# examples and data files from GitHub.

FAQ

Why convert HTML from a ZIP archive to JPG?

Use this workflow when the HTML document and its resources must stay packaged together, but the final result should be a raster image.

Can the ZIP archive contain CSS and images?

Yes. The archive can contain the HTML document and related resources such as CSS files, images, scripts, and fonts referenced by relative paths.

Is the ZIP handler specific to JPG output?

No. The handler resolves resources from the archive. The output format is controlled by the rendering workflow, so the same idea can be used for PDF or other supported outputs.

Related Articles

• Convert HTML from ZIP Archive to PDF – render the same kind of packaged HTML input to PDF.
• Execution Time Logging – add request duration logging to a ZIP-based conversion pipeline.
• Message Handler Use Cases in C# – compare common custom message handler workflows.