Zeiterfassung – HTML konvertieren – C# Beispiel

In diesem Artikel finden Sie ein Beispiel für die Verwendung benutzerdefinierter Nachrichtenhandler zur Konvertierung von HTML aus einem ZIP-Archiv in PDF und zur Protokollierung der Ausführungszeit dieses Prozesses.

Um die Leistung zu optimieren, müssen Sie manchmal die Ausführungszeit von Webanfragen herausfinden. Sie möchten beispielsweise wissen, wie viel Zeit für die Konvertierung einer HTML-basierten Datei aus einem ZIP-Archiv in PDF benötigt wird.

Protokollierung der Ausführungszeit

Erstellen eines Nachrichten-Handlers für eine benutzerdefinierte Schema-Implementierung

Lassen Sie uns einen benutzerdefinierten Handler erstellen, den Sie für die Implementierung eines benutzerdefinierten Schemas (Protokolls) verwenden können. Führen Sie die nächsten Schritte aus:

1. Verwenden Sie den erforderlichen Namespace, d. h. Aspose.Html.Net.
2. Definieren Sie Ihre eigene CustomSchemaMessageHandler-Klasse, die von der MessageHandler-Klasse abgeleitet wird.
3. Initialisieren Sie eine Instanz der Klasse CustomSchemaMessageHandler und definieren Sie eine Filter-Eigenschaft für sie.
4. Erstellen Sie die Klasse CustomSchemaMessageFilter, die von der Klasse MessageFilter abgeleitet ist.
5. Überschreiben Sie die Methode Match() der Klasse MessageFilter, um das Verhalten des benutzerdefinierten Nachrichten-Handlers zu implementieren.

Der folgende Codeschnipsel zeigt, wie die Klasse CustomSchemaMessageHandler erstellt wird:

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

Der Konstruktor CustomSchemaMessageHandler(schema) instanziiert das CustomSchemaMessageHandler-Objekt und nimmt das schema als Parameter an. Die Add()-Methode fügt das CustomSchemaMessageFilter-Objekt an das Ende der Sammlung an. Die Match()-Methode prüft, ob ein “Kontext” die Filterkriterien erfüllt.

Erstellen des ZipFileSchemaMessageHandlers für die Arbeit mit ZIP-Archiven

Das folgende Codeschnipsel zeigt, wie man die Klasse ZipFileSchemaMessageHandler für die Arbeit mit ZIP-Archiven erstellt:

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

Im obigen Beispiel wird nach einer Ressource (Zip-Archiv) unter ihrer URI gesucht. Wenn eine Ressource gefunden wird, gibt die Methode FromFileExtension() den MimeType der Ressource zurück.

Message Handler für eine Web-Anfrage Ausführungszeitprotokollierung

Das folgende Codeschnipsel zeigt, wie man StartRequestDurationLoggingMessageHandler und StopRequestDurationLoggingMessageHandler erstellt, um die Zeit für die Ausführung von Webanfragen zu protokollieren.

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

Hinzufügen der Nachrichten-Handler zur Pipeline

Das Schlüsselkonzept der Message-Handler besteht darin, sie miteinander zu verketten. Wir haben mehrere Message Handler erstellt und sollten sie in einer bestimmten Reihenfolge zur Pipeline hinzufügen, um das Beispiel der Zeitprotokollierung der HTML-Konvertierung von ZIP-Archiven in PDF zu implementieren. Führen wir die folgenden Schritte aus:

1. Erstellen Sie eine Instanz der Klasse Configuration.
2. Realisieren Sie das benutzerdefinierte ZIP-Schema. Verwenden Sie die Methode Add(), um ZipFileSchemaMessageHandler an das Ende der Pipeline anzuhängen.
3. Ausführen der Dauerprotokollierung. Verwenden Sie die Insert()-Methode, um den StartRequestDurationLoggingMessageHandler zuerst in die Pipeline einzufügen, und die Add()-Methode, um den StopRequestDurationLoggingMessageHandler an das Ende der Pipeline anzuhängen.
4. Initialisiert ein HTML-Dokument mit der angegebenen Konfiguration.
5. Erstellen Sie das PDF-Gerät und rendern Sie HTML in 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);

Der Konstruktor Configuration() erzeugt eine Instanz der Klasse Configuration. Nachdem die Konfiguration erstellt wurde, werden die Methoden GetService<INetworkService>(), MessageHandlers.Add() und MessageHandlers.Insert() aufgerufen. Die Insert()- und Add()-Methoden fügen die benutzerdefinierten Message-Handler in die Sammlung der vorhandenen Message-Handler ein. Die Abbildung zeigt die Kette der Message-Handler für dieses Beispiel:

Hinweis: Der HTMLDocument(address, configuration) Konstruktor nimmt den absoluten Pfad zum ZIP-Archiv. Alle zugehörigen Ressourcen haben jedoch relative Pfade im HTML-Dokument und im Code des Beispiels.

Sie können die vollständigen Beispiele und Datendateien von GitHub herunterladen.