Time Logging – Convert HTML – C# example

In this article, you will find an example of using custom message handlers to convert HTML from ZIP archive to PDF and log the execution time of this process.

Sometimes, in order to optimize the performance, you may need to find out the web request execution time. For example, you want to know how much time is taken to convert HTML-based file from a ZIP archive to PDF.

Execution Time Logging

Creating a Message Handler for a Custom Schema Implementation

Let’s create a custom handler that you can use for custom schema (protocol) implementation. Take the next steps:

1. Use the necessary Namespace, which is the Aspose.Html.Net.
2. Define your own CustomSchemaMessageHandler class that will be derived from the MessageHandler class.
3. Initialize an instance of the CustomSchemaMessageHandler class and define a Filter property for it.
4. Create the CustomSchemaMessageFilter class that is derived from the MessageFilter class.
5. Override the Match() method of the MessageFilter class to implement the custom message handler behaviour.

The following code snippet shows how to create the CustomSchemaMessageHandler class:

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

The CustomSchemaMessageHandler(schema) constructor instantiates the CustomSchemaMessageHandler object and takes the schema as a parameter. The Add() method append the CustomSchemaMessageFilter object at the end of the collection. The Match() method tests whether a context satisfies the filter criteria.

Creating the ZipFileSchemaMessageHandler for Working with ZIP archives

The following code snippet shows how to create the ZipFileSchemaMessageHandler class for working with ZIP archives:

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

In the above example, searching for a resource (zip archive) at its URI is realized. If a resource is found, FromFileExtension() method returns the MimeType of the resource.

Message Handler for a Web Request Execution Time Logging

The following code snippet shows how to create StartRequestDurationLoggingMessageHandler and StopRequestDurationLoggingMessageHandler to log the time taken for web request execution.

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

Adding the Message Handlers to the Pipeline

The key concept of message handlers work is chaining them together. We have created several message handlers and should add them to the pipeline in a specific order to implement the example of HTML from ZIP archive to PDF conversion time logging. Let’s perform the following steps:

1. Create an instance of the Configuration class.
2. Realize ZIP Custom Schema. Use the Add() method to append ZipFileSchemaMessageHandler to the end of the pipeline.
3. Execute Duration Logging. Use the Insert() method to add the StartRequestDurationLoggingMessageHandler first in the pipeline, and the Add() method to append the StopRequestDurationLoggingMessageHandler to the end of the pipeline.
4. Initialize an HTML document with specified configuration.
5. Create the PDF Device and render HTML to 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);

The Configuration() constructor creates an instance of the Configuration class. After the configuration is created, the GetService<INetworkService>(), MessageHandlers.Add() and MessageHandlers.Insert() methods are invoked. The Insert() and Add() methods append the custom message handlers in the collection of existing message handlers. The figure shows the chain of message handlers for this example:

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.

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