Registro de tiempo – Convertir HTML – Ejemplo de C#

En este artículo, encontrará un ejemplo del uso de controladores de mensajes personalizados para convertir HTML de un archivo ZIP a PDF y registrar el tiempo de ejecución de este proceso.

A veces, para optimizar el rendimiento, es posible que necesite conocer el tiempo de ejecución de la solicitud web. Por ejemplo, desea saber cuánto tiempo se tarda en convertir un archivo basado en HTML de un archivo ZIP a PDF.

Registro de tiempo de ejecución

Crear un controlador de mensajes para una implementación de esquema personalizado

Creemos un controlador personalizado que pueda usar para la implementación de un esquema (protocolo) personalizado. Tome los siguientes pasos:

1. Utilice el espacio de nombres necesario, que es Aspose.Html.Net.
2. Defina su propia clase CustomSchemaMessageHandler que se derivará de la clase MessageHandler.
3. Inicialice una instancia de la clase CustomSchemaMessageHandler y defina una propiedad Filter para ella.
4. Cree la clase CustomSchemaMessageFilter que se deriva de la clase MessageFilter.
5. Anule el método Match() de la clase MessageFilter para implementar el comportamiento personalizado del controlador de mensajes.

El siguiente fragmento de código muestra cómo crear la clase CustomSchemaMessageHandler:

// Define the CustomSchemaMessageFilter class that is derived from the MessageFilter class
class CustomSchemaMessageFilter : MessageFilter
{
    private readonly string schema;
    public CustomSchemaMessageFilter(string schema)
    {
        this.schema = schema;
    }
    // Override the Match() method
    public override bool Match(INetworkOperationContext context)
    {
        return string.Equals(schema, context.Request.RequestUri.Protocol.TrimEnd(':'));
    }
}

// Define the CustomSchemaMessageHandler class that is derived from the MessageHandler class
abstract class CustomSchemaMessageHandler : MessageHandler
{
    // Initialize an instance of the CustomSchemaMessageHandler class
    protected CustomSchemaMessageHandler(string schema)
    {
        Filters.Add(new CustomSchemaMessageFilter(schema));
    }
}

El constructor CustomSchemaMessageHandler(schema) crea una instancia del objeto CustomSchemaMessageHandler y toma el schema como parámetro. El método Add() agrega el objeto CustomSchemaMessageFilter al final de la colección. El método Match() prueba si un context satisface los criterios del filtro.

Creación de ZipFileSchemaMessageHandler para trabajar con archivos ZIP

El siguiente fragmento de código muestra cómo crear la clase ZipFileSchemaMessageHandler para trabajar con archivos ZIP:

// Define the ZipFileSchemaMessageHandler class that is derived from the CustomSchemaMessageHandler class
class ZipFileSchemaMessageHandler : CustomSchemaMessageHandler
{
    private readonly Archive archive;

    public ZipFileSchemaMessageHandler(Archive archive) : base("zip-file")
    {
        this.archive = archive;
    }

    // Override the Invoke() method
    public override void Invoke(INetworkOperationContext context)
    {
        var pathInsideArchive = context.Request.RequestUri.Pathname.TrimStart('/').Replace("\\", "/");
        var stream = GetFile(pathInsideArchive);

        if (stream != null)
        {
            // If a resource is found in the archive, then return it as a Response
            var response = new ResponseMessage(HttpStatusCode.OK);
            response.Content = new StreamContent(stream);
            response.Headers.ContentType.MediaType = MimeType.FromFileExtension(context.Request.RequestUri.Pathname);
            context.Response = response;
        }
        else
        {
            context.Response = new ResponseMessage(HttpStatusCode.NotFound);
        }

        // Invoke the next message handler in the chain
        Next(context);
    }

    Stream GetFile(string path)
    {
        var result = archive
            .Entries
            .FirstOrDefault(x => x.Name == path);
        return result?.Open();
    }
}

En el ejemplo anterior, se realiza la búsqueda de un recurso (archivo zip) en su URI. Si se encuentra un recurso, el método FromFileExtension() devuelve el MimeType del recurso.

Controlador de mensajes para un registro del tiempo de ejecución de una solicitud web

El siguiente fragmento de código muestra cómo crear StartRequestDurationLoggingMessageHandler y StopRequestDurationLoggingMessageHandler para registrar el tiempo necesario para la ejecución de la solicitud web.

// Define the RequestDurationLoggingMessageHandler class that is derived from the MessageHandler class
abstract class RequestDurationLoggingMessageHandler : MessageHandler
{
    private static ConcurrentDictionary<Url, Stopwatch> requests = new ConcurrentDictionary<Url, Stopwatch>();

    protected void StartTimer(Url url)
    {
        requests.TryAdd(url, Stopwatch.StartNew());
    }

    protected TimeSpan StopTimer(Url url)
    {
        var timer = requests[url];
        timer.Stop();
        return timer.Elapsed;
    }
}

class StartRequestDurationLoggingMessageHandler : RequestDurationLoggingMessageHandler
{
    // Override the Invoke() method
    public override void Invoke(INetworkOperationContext context)
    {
        // Start the stopwatch
        StartTimer(context.Request.RequestUri);

        // Invoke the next message handler in the chain
        Next(context);
    }
}

class StopRequestDurationLoggingMessageHandler : RequestDurationLoggingMessageHandler
{
    // Override the Invoke() method
    public override void Invoke(INetworkOperationContext context)
    {
        // Stop the stopwatch
        var duration = StopTimer(context.Request.RequestUri);

        // Print the result
        Debug.WriteLine($"Elapsed: {duration:g}, resource: {context.Request.RequestUri.Pathname}");

        // Invoke the next message handler in the chain
        Next(context);
    }
}

Agregar los controladores de mensajes a la canalización

El concepto clave del trabajo de los manejadores de mensajes es encadenarlos. Hemos creado varios controladores de mensajes y debemos agregarlos a la canalización en un orden específico para implementar el ejemplo de registro de tiempo de conversión de HTML de archivo ZIP a PDF. Realicemos los siguientes pasos:

1. Cree una instancia de la clase Configuración.
2. Implemente el esquema personalizado ZIP. Utilice el método Add() para agregar ZipFileSchemaMessageHandler al final de la canalización.
3. Ejecute el registro de duración. Utilice el método Insert() para agregar StartRequestDurationLoggingMessageHandler primero en la canalización y el método Add() para agregar StopRequestDurationLoggingMessageHandler al final de la canalización.
4. Inicialice un documento HTML con la configuración especificada.
5. Cree el dispositivo PDF y renderice HTML a PDF.

// 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-duration.pdf");

// Create an instance of the Configuration class
using var configuration = new Configuration();
var service = configuration.GetService<INetworkService>();
var handlers = service.MessageHandlers;

// Custom Schema: ZIP. Add ZipFileSchemaMessageHandler to the end of the pipeline
handlers.Add(new ZipFileSchemaMessageHandler(new Archive(documentPath)));

// Duration Logging. Add the StartRequestDurationLoggingMessageHandler at the first place in the pipeline
handlers.Insert(0, new StartRequestDurationLoggingMessageHandler());

// Add the StopRequestDurationLoggingMessageHandler to the end of the pipeline
handlers.Add(new StopRequestDurationLoggingMessageHandler());

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

// Create the PDF Device
using var device = new PdfDevice(savePath);

// Render ZIP to PDF
document.RenderTo(device);

El constructor Configuration() crea una instancia de la clase Configuration. Una vez creada la configuración, se invocan los métodos GetService<INetworkService>(), MessageHandlers.Add() y MessageHandlers.Insert(). Los métodos Insert() y Add() agregan los controladores de mensajes personalizados en la colección de controladores de mensajes existentes. La figura muestra la cadena de controladores de mensajes para este ejemplo:

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.

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