Convertir HTML de un archivo ZIP a JPG – ejemplo de C#

En este artículo, creamos un controlador de mensajes personalizado para realizar una tarea específica: convertir HTML de un archivo ZIP a JPG.

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

Hay muchas razones por las que necesitarías convertir HTML de un archivo ZIP al formato JPG. Por ejemplo, si desea convertir un documento HTML (XHTML) que contiene recursos vinculados a JPG, debe empaquetar todos estos recursos junto con el documento en un único archivo ZIP y convertirlo a JPG. Aspose.HTML for .NET proporciona funcionalidad para crear controladores de mensajes personalizados para trabajar con archivos ZIP.

Crear un controlador de mensajes personalizado

Aspose.HTML for .NET ofrece funcionalidad para la creación de un controlador de mensajes personalizado. Diseñemos el controlador personalizado que podemos usar para trabajar con archivos ZIP. Tome los siguientes pasos:

1. Utilice el espacio de nombres necesario, que es Aspose.Html.Net. Este espacio de nombres se presenta mediante clases e interfaces que son responsables de facilitar el procesamiento de la red.

2. Para crear un controlador de mensajes personalizado, debe definir su propia clase que se derivará de la clase MessageHandler. La clase MessageHandler representa un tipo base para controladores de mensajes.

using Aspose.Html.Net;
...

	class ZipArchiveMessageHandler : MessageHandler
	{
	}

4. Anule el método Invoke() de la clase MessageHandler para implementar el comportamiento personalizado del controlador de mensajes.

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

Consideremos más de cerca el fragmento de código:

• El ZipArchiveMessageHandler personalizado debe heredar de la clase MessageHandler base. Tiene dos variables: el archivo y la representación de cadena de la ruta al archivo. Es necesario heredar de IDisposable para proporcionar un mecanismo para la liberación determinista de recursos no administrados.

• El controlador de mensajes tiene el concepto de filtrado. En este caso, se agrega un filtro de protocolo (esquema), este controlador de mensajes solo funcionará con el protocolo "zip".

  El filtrado de mensajes por protocolo de recursos se implementa utilizando la clase ProtocolMessageFilter. El constructor ProtocolMessageFilter() inicializa una nueva instancia de la clase ProtocolMessageFilter. Toma como parámetro los protocolos "zip".

• El método Invoke() implementa el comportamiento del controlador de mensajes. Se llama para cada controlador en la canalización y toma un “contexto” como parámetro. El método GetFile() define la lógica en el método Invoke(). Implementa la cadena de tareas, después de lo cual se llama al siguiente controlador Next(context).

  El método GetFile() realiza una búsqueda de datos como una matriz de bytes en un archivo zip basada en la Solicitud y los formularios de Respuesta.

• context proporciona información contextual para los servicios de red, la entidad de la operación pasa a través de él y se devuelve el resultado de la operación. En Aspose.HTML, el context se realiza mediante la interfaz INetworkOperationContext que tiene dos propiedades (parámetros): Request y Response.

Agregue ZipArchiveMessageHandler a la canalización

El concepto clave del trabajo de los controladores de mensajes es encadenarlos, y ahora necesitaría agregar ZipArchiveMessageHandler en el proceso. El constructor Configuration() crea una instancia de la clase Configuration. Una vez creada la configuración, se invocan los métodos GetService<INetworkService>() y MessageHandlers.Add(). El método Add() toma un objeto zip como parámetro y agrega ZipArchiveMessageHandler al final de la colección de controladores de mensajes.

// 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);

En el ejemplo, el archivo ZIP (test.zip) tiene el documento HTML (test.html) en el que todos los recursos relacionados tienen rutas relativas al documento HTML.

Nota: El constructor HTMLDocument(address, configuration) toma la ruta absoluta al archivo ZIP. Pero todos los recursos relacionados tienen rutas relativas en el documento HTML y en el código del ejemplo.

Para obtener más información sobre cómo convertir HTML a JPG usando el método Renderto(device), lea el artículo Ajuste de convertidores.

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