Save HTML Document – C# Examples

After downloading an existing file or creating an HTML document from scratch, you can save the changes using one of the HTMLDocument.Save() methods. There are overloaded methods to save a document to a file, URL, or streams.

• The API provides Aspose.Html.Saving namespace with the SaveOptions and ResourceHandlingOptions classes that allow you to set options for saving operations.
• The API provides Aspose.Html.Saving.ResourceHandlers namespace that contains ResourceHandler and FileSystemResourceHandler classes responsible for handling resources.

Please note that we have two different concepts for creating the output files:

• The first conception is based on producing the HTML like files as output. The SaveOptions as a base class for this approach helps to handle the saving process of related resources such as scripts, styles, images, etc. The ResourceHandler class is responsible for handling resources. It is developed to save HTML content and resources into streams and provides methods that allow you to control what will be done with the resource.
• The second concept could be used to creating a visual representation of HTML as a result. The base class for this conception is RenderingOptions; it has specialized methods to specify the page size, page-margins, resolution, user-styles, etc.

This article only describes how to use SaveOptions and ResourceHandler classes. To read more about the rendering mechanism, please follow the Renderers and Rendering Options articles.

SaveOptions & ResourceHandlingOptions

The SaveOptions is a base class that allows you to specify additional options for saving operations and helps to manage the linked resources. The ResourceHandlingOptions property of the SaveOptions class is used for configuration of resources handling. The ResourceHandlingOptions class represents resource handling options and the list of available ones are demonstrated in the following table:

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 options specifies behavior for other than JavaScript files.

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

Save HTML

Once you have finished your changes in HTML, you may want to save the document. You can do it using one of the Save() methods of the HTMLDocument class. The following example is the easiest way to save an HTML file:

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

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

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

In the example above, we use the HTMLDocument() constructor for initializing an empty HTML document. The CreateTextNode(data) method of the HTMLDocument class creates a text node given the specified string. The Save(path) method saves the document to a local file specified by path.

The sample above is quite simple. However, in real-life applications, you often need additional control over the saving process. The next few sections describe how to use resource handling options or save you document to the different formats.

Save HTML to a File

The following code snippet shows how to use ResourceHandlingOptions property of the SaveOptions class to manage linked to your document files.

using System.IO;
using Aspose.Html;
using Aspose.Html.Saving;
...
    // Prepare an output path for a 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("linked.html", "<p>Hello linked file!</p>");

    // Load the "save-with-linked-file.html" into memory
    using (var document = new HTMLDocument(documentPath))
    {
        // Create a save options instance
        var 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);
    }

Save HTML to a Local File System Storage

The HTML document can contain different resources like CSS, external images and files. Aspose.HTML provides a way to save HTML with all linked files – the ResourceHandler class is developed for saving HTML content and resources to streams. This class is responsible for handling resources and provides methods that allow you to control what is done with each resource.

Let’s consider an example of saving HTML with resourses to user-specified local file storage. The source with-resources.html document and its linked image file are in the same directory. The FileSystemResourceHandler(customOutDir) constructor takes a path indicating where the document with resources will be saved and creates a FileSystemResourceHandler object. The Save(resourceHandler) method takes this object and saves HTML to the output storage.

using System.IO;
using Aspose.Html;
using Aspose.Html.Saving.ResourceHandlers;
...

    // 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/save/");

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

Save HTML to a Zip Archive

You can implement the ResourceHandler by creating ZipResourceHandler class. It allows you to create a structured and compressed archive containing HTML documents and associated resources, making it suitable for scenarios such as archiving and storage optimization. The HandleResource() method in the ZipResourceHandler class serves to customize the behavior of how individual resources are processed and stored in a Zip archive.

In the following example, the ZipResourceHandler class is used to save the with-resources.html document along with its linked resources to a Zip archive:

using System.IO;
using Aspose.Html;
using Aspose.Html.Saving;
using Aspose.Html.Saving.ResourceHandlers;
using System.IO.Compression;
...

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

    var dir = Directory.GetCurrentDirectory();

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

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

The ResourceHandler class is intended for customer implementation. The ZipResourceHandler class extends the ResourceHandler base class and provides a convenient way to manage the entire process of handling and storing resources linked with an HTML document 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)
        {
            var zipUri = (streamsCounter++ == 0
                ? Path.GetFileName(resource.OriginalUrl.Href)
                : Path.Combine(Path.GetFileName(Path.GetDirectoryName(resource.OriginalUrl.Href)),
                    Path.GetFileName(resource.OriginalUrl.Href)));
            var samplePrefix = String.Empty;
            if (initialized)
                samplePrefix = "my_";
            else
                initialized = true;

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

Save HTML to Memory Streams

The ResourceHandler class implementation in the MemoryResourceHandler class allows saving HTML to memory streams. The following code shows how to use the MemoryResourceHandler class to store an HTML document in memory, collecting and printing information about the handled resources.

1. Initialize an HTML Document using the specified HTML file path.
2. Create an instance of the MemoryResourceHandler class. This class is designed to capture and store resources within memory streams during the resource-handling process.
3. Call the Save() method of the HTML document and pass it the MemoryResourceHandler instance as an argument. This associates the resource handling logic of the MemoryResourceHandler with the HTML document-saving process.
4. Use the PrintInfo() method of the MemoryResourceHandler to print information about the handled resources.

using System.IO;
using Aspose.Html;
using Aspose.Html.Saving;
using Aspose.Html.Saving.ResourceHandlers;
using System.Collections.Generic;
...

    // Prepare a path to a source HTML file 
    string inputPath = Path.Combine(DataDir, "with-resources.html");
    
    // Load the HTML document
    using (var doc = new HTMLDocument(inputPath))
    {
        // Create an instance of the MemoryResourceHandler class and save HTML to memory
        var resourceHandler = new MemoryResourceHandler();
        doc.Save(resourceHandler);
        resourceHandler.PrintInfo();
    }

After the example run, the message about memory storage will be printed:

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

The ResourceHandler is a base class that supports the creation and management of output streams. The MemoryResourceHandler class allows you to capture and store resources in-memory streams, providing a dynamic and flexible way to handle resources without physically saving them to the file system. The following code snippet shows the realization of the ResourceHandler in the MemoryResourceHandler class:

    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)
        {
            var 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 (var stream in Streams)
                Console.WriteLine($"uri:{stream.Item2.OutputUrl}, length:{stream.Item1.Length}");
        }
    }

Save HTML to MHTML

In some cases, you need to save your web page as a single file. MHTML document could be handy and helpful for this purpose since it is a web-page archive and it stores everything inside itself. The HTMLSaveFormat Enumeration specifies the format in which document is saved, it can be HTML, MHTML, and MD formats. The example below shows how to use the Save(path, saveFormat) method for HTML to MHTML saving.

using System.IO;
using Aspose.Html;
using Aspose.Html.Saving;
...
    // Prepare an output path for a document saving
    string documentPath = Path.Combine(OutputDir, "save-to-MTHML.mht");

    // Prepare a simple HTML file with a linked document
    File.WriteAllText("document.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 "document.html" into memory
    using (var document = new HTMLDocument("document.html"))
    {
        // Save the document to MHTML format
        document.Save(documentPath, HTMLSaveFormat.MHTML);

    }

The saved “save-to-MTHML.mht” file stores HTML of the “document.html” and “linked-file.html” files.

Save HTML to Markdown

Markdown is a markup language with plain-text syntax. As well as for HTML to MHTML example, you can use the HTMLSaveFormat for HTML to MD saving. Please take a look at the following example:

using System.IO;
using Aspose.Html;
using Aspose.Html.Saving;
...
    // Prepare an output path for a document saving
    string documentPath = Path.Combine(OutputDir, "save-to-MD.md");

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

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

For the more information how to use Markdown Converter, please visit the HTML to Markdown Conversion article.

Save SVG

Usually, you could see SVG as a part of an HTML file, it is used to represent the vector data on the page: images, icons, tables, etc. However, SVG also could be extracted from the web page and you can manipulate it in a similar way as the HTML document.

Since SVGDocument and HTMLDocument are based on the same WHATWG DOM standard, all operations such as loading, reading, editing, converting and saving are similar for both documents. So, all examples where you can see manipulation with the HTMLDocument are applicable for the SVGDocument as well.

To save your changes, please use follows:

using System.IO;
using Aspose.Html;
using Aspose.Html.Dom.Svg;
...
    // Prepare an output path for an SVG document saving
    string documentPath = Path.Combine(OutputDir, "save-to-SVG.svg");

    // Prepare SVG code
    var 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 (var document = new SVGDocument(code, "."))
    {
        // Save the SVG file to a disk
        document.Save(documentPath);
    }

For more information about SVG Basics Drawing and and the API usage for the processing and rendering of SVG documents, see the Aspose.SVG for .NET Documentation.

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