Convertir HTML de un archivo ZIP a PDF – 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 PDF.

Hay muchas razones por las que necesitarías convertir HTML de un archivo ZIP a formato PDF. El PDF tiene muchas ventajas que otros archivos no tienen. Por ejemplo, muchos programas y aplicaciones admiten documentos PDF; la mayoría de los navegadores web, como Chrome y Firefox, pueden mostrar un PDF. Los archivos PDF están optimizados para imprimir; son ideales para crear copias físicas de sus documentos. PDF admite muchos algoritmos de compresión. Puede configurar los ajustes de seguridad para su archivo PDF, etc.

Crear un controlador de mensajes personalizado

Aspose.HTML for .NET ofrece funcionalidad para la creación de controladores de mensajes personalizados. Diseñemos un controlador personalizado que podamos 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. Es necesario heredar de IDisposable para proporcionar un mecanismo para la liberación determinista de recursos no administrados.

using Aspose.Html.Net;
...

	class ZipArchiveMessageHandler : MessageHandler, IDisposable
	{
	}

Entonces, ha definido su propia clase ZipArchiveMessageHandler, ahora necesita realizar algunas operaciones dentro de ella. 3. Inicialice una instancia de la clase ZipArchiveMessageHandler y defina una propiedad Filter para ella.

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

Echemos un vistazo más de cerca a este fragmento de código:

• En primer lugar, 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.

• El controlador de mensajes tiene el concepto de filtrado. En este caso, se agrega un filtro de protocolo (esquema); este controlador de mensajes sólo funcionará con el protocolo "zip". Es decir, si el recurso tiene un protocolo "zip", ZipArchiveMessageHandler lo procesará.

  El filtrado de mensajes por protocolo de recursos se implementa mediante 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 context 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. La solicitud obtiene o establece el mensaje de solicitud, la respuesta obtiene o establece el mensaje de respuesta. La Solicitud contiene información para una solicitud web, por ejemplo, una URL: una ruta a un recurso, encabezados, etc. La Respuesta contiene la respuesta que devolvió el punto final (Internet).

Agregar ZipArchiveMessageHandler en la canalización

Ahora deberá agregar ZipArchiveMessageHandler en el proceso. Utilice el método Add() que toma un objeto zip como parámetro y agrega ZipArchiveMessageHandler al final de la colección de controladores de mensajes.

La propiedad INetworkService.MessageHandlers obtiene una lista de instancias de MessageHandler que se invocarán cuando se ejecuta RequestMessage.

// Convert HTML from a ZIP archive to PDF 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-pdf.pdf");

// 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 the PDF Device  
using PdfDevice device = new PdfDevice(savePath);

// Render ZIP to PDF
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.

Lea el artículo Convserters de ajuste fino para obtener más información sobre cómo convertir HTML a PDF usando el método Renderto(device).

Aspose.HTML proporciona un Convertidor de ZIP a PDF en línea gratuito que le permite convertir HTML de forma rápida, sencilla y clara desde un archivo ZIP a PDF. Cargue, convierta archivos y obtenga resultados en segundos. No se requiere software adicional. ¡Pruebe nuestro robusto convertidor gratis ahora!