Enregistrement du temps – Conversion HTML – Exemple C#

Dans cet article, vous trouverez un exemple d’utilisation de gestionnaires de messages personnalisés pour convertir le code HTML d’une archive ZIP en PDF et enregistrer le temps d’exécution de ce processus.

Parfois, afin d’optimiser les performances, vous pouvez avoir besoin de connaître le temps d’exécution d’une requête web. Par exemple, vous voulez savoir combien de temps prend la conversion d’un fichier HTML d’une archive ZIP en PDF.

Enregistrement du temps d’exécution

Création d’un gestionnaire de messages pour une implémentation de schéma personnalisé

Créons un gestionnaire personnalisé que vous pourrez utiliser pour la mise en œuvre d’un schéma (protocole) personnalisé. Suivez les étapes suivantes :

1. Utilisez l’espace de nommage nécessaire, à savoir Aspose.Html.Net.
2. Définissez votre propre classe CustomSchemaMessageHandler qui sera dérivée de la classe MessageHandler.
3. Initialiser une instance de la classe CustomSchemaMessageHandler et lui définir une propriété Filter.
4. Créez la classe CustomSchemaMessageFilter dérivée de la classe MessageFilter.
5. Surchargez la méthode Match() de la classe MessageFilter pour implémenter le comportement du gestionnaire de messages personnalisé.

L’extrait de code suivant montre comment créer la classe CustomSchemaMessageHandler :

// Monitor network requests by custom protocol in C # using schema-based message filter and handler

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

Le constructeur CustomSchemaMessageHandler(schema) instancie l’objet CustomSchemaMessageHandler et prend le schema comme paramètre. La méthode Add() ajoute l’objet CustomSchemaMessageFilter à la fin de la collection. La méthode Match() teste si un contexte répond aux critères du filtre.

Création du ZipFileSchemaMessageHandler pour travailler avec des archives ZIP

L’extrait de code suivant montre comment créer la classe ZipFileSchemaMessageHandler pour travailler avec des archives ZIP :

// Handle zip file protocol requests in c#

// 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)
    {
        string pathInsideArchive = context.Request.RequestUri.Pathname.TrimStart('/').Replace("\\", "/");
        Stream stream = GetFile(pathInsideArchive);

        if (stream != null)
        {
            // If a resource is found in the archive, then return it as a Response
            ResponseMessage 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)
    {
        ArchiveEntry result = archive
            .Entries
            .FirstOrDefault(x => x.Name == path);
        return result?.Open();
    }
}

Dans l’exemple ci-dessus, la recherche d’une ressource (archive zip) à son URI est réalisée. Si une ressource est trouvée, la méthode FromFileExtension() renvoie le MimeType de la ressource.

Gestionnaire de messages pour une requête Web Enregistrement du temps d’exécution

L’extrait de code suivant montre comment créer StartRequestDurationLoggingMessageHandler et StopRequestDurationLoggingMessageHandler pour enregistrer le temps nécessaire à l’exécution d’une requête web.

// Track and log HTTP request durations using C# message handlers

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

Ajout des gestionnaires de messages au pipeline

Le concept clé du fonctionnement des gestionnaires de messages consiste à les enchaîner les uns aux autres. Nous avons créé plusieurs gestionnaires de messages et devons les ajouter au pipeline dans un ordre spécifique pour mettre en œuvre l’exemple de l’enregistrement du temps de conversion du HTML d’une archive ZIP en PDF. Exécutons les étapes suivantes :

1. Créer une instance de la classe Configuration.
2. Réaliser le schéma personnalisé ZIP. Utilisez la méthode Add() pour ajouter ZipFileSchemaMessageHandler à la fin du pipeline.
3. Exécuter l’enregistrement de la durée. Utilisez la méthode Insert() pour ajouter le StartRequestDurationLoggingMessageHandler en premier dans le pipeline, et la méthode Add() pour ajouter le StopRequestDurationLoggingMessageHandler à la fin du pipeline.
4. Initialise un document HTML avec la configuration spécifiée.
5. Créer le dispositif PDF et convertir le HTML en PDF.

// Implement custom zip schema with request duration logging using C# message handlers

// 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 Configuration configuration = new Configuration();
INetworkService service = configuration.GetService<INetworkService>();
MessageHandlerCollection 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 HTMLDocument document = new HTMLDocument("zip-file:///test.html", configuration);

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

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

Le constructeur Configuration() crée une instance de la classe Configuration. Une fois la configuration créée, les méthodes GetService<INetworkService>(), MessageHandlers.Add() et MessageHandlers.Insert() sont invoquées. Les méthodes Insert() et Add() ajoutent les gestionnaires de messages personnalisés à la collection de gestionnaires de messages existants. La figure montre la chaîne de gestionnaires de messages pour cet exemple :

Note: Le constructeur HTMLDocument(address, configuration) prend le chemin absolu vers l’archive ZIP. Mais toutes les ressources associées ont des chemins relatifs dans le document HTML et dans le code de l’exemple.

Vous pouvez télécharger les exemples complets et les fichiers de données sur GitHub.