HTML aus ZIP-Archiv in JPG konvertieren – C#-Beispiel

In diesem Artikel erstellen wir einen benutzerdefinierten Message Handler, um eine bestimmte Aufgabe zu erfüllen – die Konvertierung von HTML aus einem ZIP-Archiv in JPG.

Es gibt viele Gründe, warum Sie HTML aus einem ZIP-Archiv in das Format JPG konvertieren müssen. Wenn Sie z.B. ein HTML(XHTML)-Dokument, das verlinkte Ressourcen enthält, in das JPG-Format konvertieren wollen, sollten Sie alle diese Ressourcen zusammen mit dem Dokument in ein einziges ZIP-Archiv packen und es in das JPG-Format konvertieren. Aspose.HTML for .NET bietet Funktionen zur Erstellung benutzerdefinierter Nachrichten-Handler für die Arbeit mit ZIP-Archiven.

Erstellen eines benutzerdefinierten Nachrichten-Handlers

Aspose.HTML for .NET bietet Funktionen für die Erstellung eines benutzerdefinierten Nachrichten-Handlers. Entwerfen wir den benutzerdefinierten Handler, den wir für die Arbeit mit ZIP-Archiven verwenden können. Führen Sie die folgenden Schritte aus:

1. Verwenden Sie den erforderlichen Namespace, nämlich Aspose.Html.Net. Dieser Namespace wird durch Klassen und Schnittstellen dargestellt, die für eine einfache Netzwerkverarbeitung verantwortlich sind.

2. Um einen benutzerdefinierten Message Handler zu erstellen, müssen Sie Ihre eigene Klasse definieren, die von der Klasse MessageHandler abgeleitet wird. Die Klasse MessageHandler stellt einen Basistyp für Message-Handler dar.

using Aspose.Html.Net;
...

	class ZipArchiveMessageHandler : MessageHandler
	{
	}

3. Initialisieren Sie eine Instanz der Klasse ZipArchiveMessageHandler und definieren Sie eine Filter-Eigenschaft für sie.

4. Überschreiben Sie die Methode Invoke() der Klasse MessageHandler, um das Verhalten des benutzerdefinierten Nachrichten-Handlers zu implementieren.

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

Betrachten wir das Codeschnipsel genauer:

• Der benutzerdefinierte ZipArchiveMessageHandler muss von der Basisklasse MessageHandler erben. Er hat zwei Variablen: das Archiv und die String-Darstellung des Pfads zum Archiv. Die Vererbung von IDisposable ist notwendig, um einen Mechanismus für die deterministische Freigabe von nicht verwalteten Ressourcen bereitzustellen.

• Der Message Handler hat das Konzept der Filterung. In diesem Fall wird ein Protokoll (Schema) Filter hinzugefügt, diese Nachricht Handler wird nur mit dem "zip"-Protokoll arbeiten.

  Die Filterung von Nachrichten nach Ressourcenprotokoll wird mit der Klasse ProtocolMessageFilter implementiert. Der Konstruktor ProtocolMessageFilter() initialisiert eine neue Instanz der Klasse ProtocolMessageFilter. Er verwendet die "zip"-Protokolle als Parameter.

• Die Methode Invoke() implementiert das Verhalten des Nachrichten-Handlers. Sie wird für jeden Handler in der Pipeline aufgerufen und nimmt einen context als Parameter an. Die Methode GetFile() definiert die Logik der Methode Invoke(). Sie implementiert die Aufgabenkette, nach der der nächste Next(context) Handler aufgerufen wird.

  Die Methode GetFile() realisiert die Suche nach Daten als Byte-Array in einem ZIP-Archiv basierend auf Anfrage und Formularantwort.

• der context liefert Kontextinformationen für Netzwerkdienste, die Entität der Operation wird über ihn übergeben und das Ergebnis der Operation wird zurückgegeben. In Aspose.HTML wird der context durch die Schnittstelle INetworkOperationContext realisiert, die zwei Eigenschaften (Parameter) hat – Request und Response.

ZipArchiveMessageHandler zur Pipeline hinzufügen

Das Schlüsselkonzept der Nachrichten-Handler ist ihre Verkettung, und Sie müssen nun ZipArchiveMessageHandler in die Pipeline aufnehmen. Der Konstruktor Configuration() erstellt eine Instanz der Klasse Configuration. Nachdem die Konfiguration erstellt wurde, werden die Methoden GetService<INetworkService>() und MessageHandlers.Add() aufgerufen. Die Add()-Methode nimmt ein zip-Objekt als Parameter entgegen und fügt ZipArchiveMessageHandler an das Ende der Sammlung der Message-Handler an.

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

// 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 an instance of Rendering Options
ImageRenderingOptions options = new ImageRenderingOptions()
{
    Format = ImageFormat.Jpeg
};

// Create an instance of Image Device
using ImageDevice device = new ImageDevice(options, savePath);

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

Im Beispiel enthält das ZIP-Archiv (test.zip) das HTML-Dokument (test.html), in dem alle zugehörigen Ressourcen Pfade relativ zum HTML-Dokument haben.

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.

Weitere Informationen zur Konvertierung von HTML in JPG mit der Methode RenderTo(device) finden Sie im Artikel Feinabstimmung von Konvertern.

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