HTML-Dokument speichern – C#-Beispiele

Nachdem Sie eine bestehende Datei heruntergeladen oder ein HTML-Dokument von Grund auf neu erstellt haben, können Sie die Änderungen mit einer der Methoden HTMLDocument.Save() speichern. Es gibt überladene Methoden zum Speichern eines Dokuments in einer Datei, einer URL oder in Streams.

• Die API bietet den Aspose.Html.Saving Namespace mit den Klassen SaveOptions und ResourceHandlingOptions, die es erlauben, Optionen für Speichervorgänge festzulegen.
• Die API bietet den Aspose.Html.Saving.ResourceHandlers Namespace, der die Klassen ResourceHandler und FileSystemResourceHandler enthält, die für die Handhabung von Ressourcen verantwortlich sind.

Bitte beachten Sie, dass wir zwei verschiedene Konzepte für die Erstellung der Ausgabedateien haben:

• Das erste Konzept basiert auf der Erzeugung von HTML-ähnlichen Dateien als Ausgabe. Die Klasse SaveOptions als Basisklasse für dieses Konzept hilft bei der Handhabung des Speichervorgangs von zugehörigen Ressourcen wie Skripten, Stilen, Bildern usw. Die Klasse ResourceHandler ist für die Handhabung von Ressourcen zuständig. Sie wurde entwickelt, um HTML-Inhalte und Ressourcen in Streams zu speichern, und bietet Methoden, mit denen Sie steuern können, was mit der Ressource geschehen soll.
• Das zweite Konzept könnte dazu verwendet werden, eine visuelle Darstellung von HTML als Ergebnis zu erstellen. Die Basisklasse für dieses Konzept ist RenderingOptions; sie verfügt über spezialisierte Methoden zur Angabe von Seitengröße, Seitenrändern, Auflösung, Benutzerstilen usw.

Dieser Artikel beschreibt nur, wie die Klassen SaveOptions und ResourceHandler verwendet werden. Um mehr über den Rendering-Mechanismus zu erfahren, lesen Sie bitte die Artikel Renderers und Rendering Options.

SaveOptions & ResourceHandlingOptions

Die Klasse SaveOptions ist eine Basisklasse, die es Ihnen ermöglicht, zusätzliche Optionen für Speichervorgänge festzulegen, und die bei der Verwaltung der verknüpften Ressourcen hilft. Die Eigenschaft ResourceHandlingOptions der Klasse SaveOptions dient zur Konfiguration der Ressourcenbehandlung. Die Klasse ResourceHandlingOptions stellt die Optionen für die Ressourcenbehandlung dar, und die Liste der verfügbaren Optionen ist in der folgenden Tabelle aufgeführt:

Option	Description
UrlRestriction	Applies restrictions to the host or folders where resources are located.
MaxHandlingDepth	If you need to save not the only specified HTML document, but also the linked HTML pages, this option gives you the ability to control the depth of the linked pages that should be saved.
JavaScript	This option specifies how do we need to treat the JavaScript files: it could be saved as a separated linked file, embed into HTML file or even be ignored.
Default	This option specifies behavior for other than JavaScript files. Gets or sets an enum, which represents the default way of resource handling. Currently, Save, Ignore, and Embed values are supported. The default value is Save.

HTML speichern

Wenn Sie Ihre Änderungen in HTML abgeschlossen haben, möchten Sie das Dokument vielleicht speichern. Dazu können Sie eine der Save() Methoden der HTMLDocument Klasse verwenden. Das folgende Beispiel ist der einfachste Weg, eine HTML-Datei zu speichern:

// Save HTML to a file using C#

// Prepare an output path for a document saving
string documentPath = Path.Combine(OutputDir, "save-to-file.html");

// Initialize an empty HTML document
using (HTMLDocument document = new HTMLDocument())
{
    // Create a text element and add it to the document
    Text text = document.CreateTextNode("Hello, World!");
    document.Body.AppendChild(text);

    // Save the HTML document to the file on a disk
    document.Save(documentPath);
}

Im obigen Beispiel verwenden wir den HTMLDocument()-Konstruktor, um ein leeres HTML-Dokument zu initialisieren. Die Methode CreateTextNode(data) der Klasse HTMLDocument erzeugt einen Textknoten mit der angegebenen Zeichenkette. Die Methode Save(path) speichert das Dokument in einer lokalen Datei, die durch den Pfad angegeben wird.

Das obige Beispiel ist recht einfach. In realen Anwendungen benötigen Sie jedoch oft zusätzliche Kontrolle über den Speichervorgang. In den nächsten Abschnitten wird beschrieben, wie Sie die Optionen zur Ressourcenbehandlung verwenden oder Ihr Dokument in den verschiedenen Formaten speichern können.

HTML in einer Datei speichern

Der folgende Codeschnipsel zeigt, wie Sie die Eigenschaft ResourceHandlingOptions der Klasse SaveOptions verwenden, um die Verknüpfung mit Ihren Dokumentdateien zu verwalten.

// Save HTML with a linked resources using C#

// Prepare an output path for an HTML document 
string documentPath = Path.Combine(OutputDir, "save-with-linked-file.html");

// Prepare a simple HTML file with a linked document
File.WriteAllText(documentPath, "<p>Hello, World!</p>" +
                                "<a href='linked.html'>linked file</a>");

// Prepare a simple linked HTML file
File.WriteAllText(Path.Combine(OutputDir, "linked.html"), "<p>Hello, linked file!</p>");

// Load the "save-with-linked-file.html" into memory
using (HTMLDocument document = new HTMLDocument(documentPath))
{
    // Create a save options instance
    HTMLSaveOptions options = new HTMLSaveOptions();

    // The following line with value '0' cuts off all other linked HTML-files while saving this instance
    // If you remove this line or change value to the '1', the 'linked.html' file will be saved as well to the output folder
    options.ResourceHandlingOptions.MaxHandlingDepth = 1;

    // Save the document with the save options
    document.Save(Path.Combine(OutputDir, "save-with-linked-file_out.html"), options);
}

Speichern von HTML in einem lokalen Dateisystemspeicher

Das HTML-Dokument kann verschiedene Ressourcen wie CSS, externe Bilder und Dateien enthalten. Aspose.HTML for .NET bietet eine Möglichkeit, HTML mit allen verknüpften Dateien zu speichern – die Klasse ResourceHandler wurde entwickelt, um HTML-Inhalte und Ressourcen in Streams zu speichern. Diese Klasse ist für die Behandlung von Ressourcen zuständig und bietet Methoden, mit denen Sie steuern können, was mit jeder Ressource geschieht.

Betrachten wir ein Beispiel für das Speichern von HTML mit Ressourcen in einem benutzerdefinierten lokalen Dateispeicher. Das Quelldokument with-resources.html und die damit verknüpfte Bilddatei befinden sich im selben Verzeichnis. Der FileSystemResourceHandler(customOutDir) Konstruktor nimmt einen Pfad, der angibt, wo das Dokument mit Ressourcen gespeichert werden soll und erzeugt ein FileSystemResourceHandler Objekt. Die Methode Save(resourceHandler) nimmt dieses Objekt und speichert HTML in den Ausgabespeicher.

// Save HTML with resources to local storage using C#

// Prepare a path to a source HTML file
string inputPath = Path.Combine(DataDir, "with-resources.html");

// Prepare a full path to an output directory 
string customOutDir = Path.Combine(Directory.GetCurrentDirectory(), "./../../../../tests-out/saving/");

// Load the HTML document from a file
using (HTMLDocument doc = new HTMLDocument(inputPath))
{
    // Save HTML with resources
    doc.Save(new FileSystemResourceHandler(customOutDir));
}

HTML in einem Zip-Archiv speichern

Sie können den ResourceHandler implementieren, indem Sie die Klasse ZipResourceHandler erstellen. Sie ermöglicht es Ihnen, ein strukturiertes und komprimiertes Archiv zu erstellen, das HTML-Dokumente und zugehörige Ressourcen enthält, und eignet sich damit für Szenarien wie Archivierung und Speicheroptimierung. Die Methode HandleResource() in der Klasse ZipResourceHandler dient zur Anpassung des Verhaltens, wie einzelne Ressourcen in einem Zip-Archiv verarbeitet und gespeichert werden.

Im folgenden Beispiel wird die Klasse ZipResourceHandler verwendet, um das Dokument with-resources.html zusammen mit seinen verknüpften Ressourcen in einem Zip-Archiv zu speichern:

// Save an HTML document with all linked resources into a ZIP archive using C#

// Prepare a path to a source HTML file 
string inputPath = Path.Combine(DataDir, "with-resources.html");

string dir = Directory.GetCurrentDirectory();

// Prepare a full path to an output zip storage
string customArchivePath = Path.Combine(dir, "./../../../../tests-out/saving/archive.zip");

// Load the HTML document 
using (HTMLDocument doc = new HTMLDocument(inputPath))
{
    // Initialize an instance of the ZipResourceHandler class
    using (ZipResourceHandler resourceHandler = new ZipResourceHandler(customArchivePath))
    {
        // Save HTML with resources to a Zip archive
        doc.Save(resourceHandler);
    }
}

Die Klasse ResourceHandler ist für die Implementierung durch den Kunden gedacht. Die Klasse ZipResourceHandler erweitert die Basisklasse ResourceHandler und bietet eine bequeme Möglichkeit, den gesamten Prozess der Handhabung und Speicherung von mit einem HTML-Dokument verknüpften Ressourcen in einem Zip-Archiv zu verwalten:

// Custom resource handler to save HTML with resources into a ZIP archive

internal class ZipResourceHandler : ResourceHandler, IDisposable
{
    private FileStream zipStream;
    private ZipArchive archive;
    private int streamsCounter;
    private bool initialized;

    public ZipResourceHandler(string name)
    {
        DisposeArchive();
        zipStream = new FileStream(name, FileMode.Create);
        archive = new ZipArchive(zipStream, ZipArchiveMode.Update);
        initialized = false;
    }

    public override void HandleResource(Resource resource, ResourceHandlingContext context)
    {
        string zipUri = (streamsCounter++ == 0
            ? Path.GetFileName(resource.OriginalUrl.Href)
            : Path.Combine(Path.GetFileName(Path.GetDirectoryName(resource.OriginalUrl.Href)),
                Path.GetFileName(resource.OriginalUrl.Href)));
        string samplePrefix = String.Empty;
        if (initialized)
            samplePrefix = "my_";
        else
            initialized = true;

        using (Stream newStream = archive.CreateEntry(samplePrefix + zipUri).Open())
        {
            resource.WithOutputUrl(new Url("file:///" + samplePrefix + zipUri)).Save(newStream, context);
        }
    }

    private void DisposeArchive()
    {
        if (archive != null)
        {
            archive.Dispose();
            archive = null;
        }

        if (zipStream != null)
        {
            zipStream.Dispose();
            zipStream = null;
        }

        streamsCounter = 0;
    }

    public void Dispose()
    {
        DisposeArchive();
    }
}

HTML in Memory Streams speichern

Die Implementierung der Klasse ResourceHandler in der Klasse MemoryResourceHandler ermöglicht das Speichern von HTML in Memory Streams. Der folgende Code zeigt, wie die Klasse MemoryResourceHandler verwendet wird, um ein HTML-Dokument im Speicher zu speichern und Informationen über die behandelten Ressourcen zu sammeln und auszudrucken.

1. Initialisieren Sie ein HTML-Dokument mit dem angegebenen HTML-Dateipfad.
2. Erstellen Sie eine Instanz der Klasse MemoryResourceHandler. Diese Klasse wurde entwickelt, um Ressourcen in Speicherströmen während des Prozesses der Ressourcenbehandlung zu erfassen und zu speichern.
3. Rufen Sie die Methode Save() des HTML-Dokuments auf und übergeben Sie ihr die Instanz MemoryResourceHandler als Argument. Dadurch wird die Logik der Ressourcenbehandlung des MemoryResourceHandler mit dem Speichervorgang des HTML-Dokuments verbunden.
4. Verwenden Sie die Methode PrintInfo() des MemoryResourceHandler, um Informationen über die behandelten Ressourcen zu drucken.

// Save HTML with resources to memory streams using C#

// Prepare a path to a source HTML file 
string inputPath = Path.Combine(DataDir, "with-resources.html");

// Load the HTML document 
using (HTMLDocument doc = new HTMLDocument(inputPath))
{
    // Create an instance of the MemoryResourceHandler class and save HTML to memory
    MemoryResourceHandler resourceHandler = new MemoryResourceHandler();
    doc.Save(resourceHandler);
    resourceHandler.PrintInfo();
}

Nach dem Ausführen des Beispiels wird die Meldung über die Speicherung des Speichers gedruckt:

uri:memory:///with-resources.html, length:256
uri:memory:///photo1.png, length:57438

Der ResourceHandler ist eine Basisklasse, die die Erstellung und Verwaltung von Ausgabeströmen unterstützt. Die Klasse MemoryResourceHandler ermöglicht es, Ressourcen in Speicherströmen zu erfassen und zu speichern und bietet damit eine dynamische und flexible Möglichkeit, Ressourcen zu handhaben, ohne sie physisch im Dateisystem zu speichern. Der folgende Codeschnipsel zeigt die Realisierung des ResourceHandlers in der MemoryResourceHandler Klasse:

// In-memory resource handler that captures and stores HTML resources as streams

internal class MemoryResourceHandler : ResourceHandler
{
    public List<Tuple<Stream, Resource>> Streams;

    public MemoryResourceHandler()
    {
        Streams = new List<Tuple<Stream, Resource>>();
    }

    public override void HandleResource(Resource resource, ResourceHandlingContext context)
    {
        MemoryStream outputStream = new MemoryStream();
        Streams.Add(Tuple.Create<Stream, Resource>(outputStream, resource));
        resource
            .WithOutputUrl(new Url(Path.GetFileName(resource.OriginalUrl.Pathname), "memory:///"))
            .Save(outputStream, context);
    }

    public void PrintInfo()
    {
        foreach (Tuple<Stream, Resource> stream in Streams)
            Console.WriteLine($"uri:{stream.Item2.OutputUrl}, length:{stream.Item1.Length}");
    }
}

HTML in MHTML speichern

In manchen Fällen müssen Sie Ihre Webseite als eine einzige Datei speichern. Das Dokument MHTML könnte für diesen Zweck praktisch und hilfreich sein, da es ein Webseitenarchiv ist und alles in sich selbst speichert. Die Aufzählung HTMLSaveFormat gibt das Format an, in dem das Dokument gespeichert wird, es können die Formate HTML, MHTML und MD sein. Das folgende Beispiel zeigt, wie die Methode Save(path, saveFormat) zum Speichern von HTML in MHTML verwendet werden kann.

// Save HTML as MHTML using C#

// Prepare an output path for a document saving
string savePath = Path.Combine(OutputDir, "save-to-mhtml.mht");

// Prepare a simple HTML file with a linked document
File.WriteAllText("save-to-mhtml.html", "<p>Hello, World!</p>" +
                                        "<a href='linked-file.html'>linked file</a>");

// Prepare a simple linked HTML file
File.WriteAllText("linked-file.html", "<p>Hello, linked file!</p>");

// Load the "save-to-mhtml.html" into memory
using (HTMLDocument document = new HTMLDocument("save-to-mhtml.html"))
{
    // Save the document to MHTML format
    document.Save(savePath, HTMLSaveFormat.MHTML);
}

Die gespeicherte Datei “save-to-mhtml.mht” speichert HTML der Dateien “document.html” und “linked-file.html”.

HTML in Markdown speichern

Markdown ist eine Auszeichnungssprache mit Klartext-Syntax. Genauso wie für das Beispiel HTML zu MHTML, können Sie das HTMLSaveFormat für das Speichern von HTML zu MD verwenden. Bitte sehen Sie sich das folgende Beispiel an:

// Save HTML as Markdown using C#

// Prepare an output path for a document saving
string documentPath = Path.Combine(OutputDir, "save-html-to-markdown.md");

// Prepare HTML code
string html_code = "<H2>Hello, World!</H2>";

// Initialize a document from a string variable
using (HTMLDocument document = new HTMLDocument(html_code, "."))
{
    // Save the document as a Markdown file
    document.Save(documentPath, HTMLSaveFormat.Markdown);
}

Weitere Informationen zur Verwendung des HTML-Konverters finden Sie in dem Artikel HTML in Markdown umwandeln.

SVG speichern

Normalerweise sieht man SVG als Teil einer HTML-Datei. Es wird verwendet, um die Vektordaten auf der Seite darzustellen: Bilder, Icons, Tabellen, usw. SVG kann jedoch auch aus der Webseite extrahiert werden und lässt sich dann auf ähnliche Weise wie ein HTML-Dokument manipulieren.

Da SVGDocument und HTMLDocument auf demselben WHATWG DOM Standard beruhen, sind alle Vorgänge wie Laden, Lesen, Bearbeiten, Konvertieren und Speichern für beide Dokumente ähnlich. Daher sind alle Beispiele, in denen Sie Manipulationen mit dem HTMLDocument sehen können, auch für das SVGDocument anwendbar.

Um Ihre Änderungen zu speichern, gehen Sie bitte wie folgt vor:

// Create and save SVG image using C#

// Prepare an output path for a document saving
string documentPath = Path.Combine(OutputDir, "create-and-save-svg.svg");

// Prepare SVG code
string code = @"
    <svg xmlns='http://www.w3.org/2000/svg' height='200' width='300'>
        <g fill='none' stroke-width= '10' stroke-dasharray='30 10'>
            <path stroke='red' d='M 25 40 l 215 0' />
            <path stroke='black' d='M 35 80 l 215 0' />
            <path stroke='blue' d='M 45 120 l 215 0' />
        </g>
    </svg>";

// Initialize an SVG instance from the content string
using (SVGDocument document = new SVGDocument(code, "."))
{
    // Save the SVG file to a disk
    document.Save(documentPath);
}

Weitere Informationen über SVG Basics Drawing und die API-Nutzung für die Verarbeitung und das Rendering von SVG-Dokumenten finden Sie in der Aspose.SVG for .NET Dokumentation.

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