Aspose.HTML for .NET 24.2 – Save HTML to a Stream

Aspose.HTML for .NET 24.2

In version 24.2, the IOutputStorage interface has been deprecated but will continue to work until version 24.5 is released. If you use earlier versions of Aspose.HTML for .NET, we recommend that you upgrade and migrate to the new version, as version 24.5 will remove this deprecated interface.

Deprecated	New
IOutputStorage Interface	ResourceHandler Class

The HTML document can contain different resources like CSS, external images, and files. In the article, we will consider the cases for saving HTML documents with resources to Zip archive and memory stream. Aspose.HTML for .NET continues to develop and enhance the ways to save HTMLs with all linked files. Here we will look at examples of saving files using deprecated classes and offer advanced solutions for implementing new classes.

ResourceHandler Class Vs IOutputStorage Interface

The ResourceHandler class allows developers to implement the HandleResource() method, in which you can create a stream yourself and release it wherever you need it. The new method adds the ability to see a Resource and process more information about it. So, by adopting the ResourceHandler class, developers can benefit from a more streamlined and expressive approach to managing resources, resulting in cleaner, more maintainable, and flexible code when saving HTML documents.

Save HTML to a Zip Archive

Here, we will examine one and the same example of saving the with-resources.html file in a Zip archive using an outdated IOutputStorage interface and a new ResourceHandler class.

Using IOutputStorage – 24.1.0 and Earlier Versions

The IOutputStorage interface was a base interface that supported the creation and management of output streams. You can implement the IOutputStorage interface by creating ZipStorage class to save HTML with resources to a Zip archive:

using System.IO;
using Aspose.Html;
using Aspose.Html.Saving;
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/old/archive.zip");

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

The following code snippet shows the realization of the IOutputStorage in the ZipStorage class to demonstrate saving an HTML document with resources to a Zip archive.

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

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

        public OutputStream CreateStream(OutputStreamContext context)
        {
            var zipUri = (streamsCounter++ == 0 ? Path.GetFileName(context.Uri) :
                Path.Combine(Path.GetFileName(Path.GetDirectoryName(context.Uri)), Path.GetFileName(context.Uri)));
            var samplePrefix = String.Empty;
            if (initialized)
                samplePrefix = "my_";
            else
                initialized = true;

            var newStream = archive.CreateEntry(samplePrefix + zipUri).Open();
            var outputStream = new OutputStream(newStream, "file:///" + samplePrefix + zipUri);
            return outputStream;
        }

        public void ReleaseStream(OutputStream stream)
        {
            stream.Flush();
            stream.Close();
        }

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

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

Using new ResourceHandler class – Since Version 24.2

The ResourceHandler class is intended for customers implementation. The following C# example shows how to save an HTML document with resources to a Zip archive using the ZipResourceHandler class of the ResourceHandler:

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/new/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 following code snippet shows the realization of the ResourceHandler in the ZipResourceHandler class to demonstrate saving an HTML document with resources to a Zip archive. The HandleResource() method of the ZipResourceHandler class is responsible for handling each resource during the saving process when creating 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

Let’s consider the C# example of saving an HTML file with linked resources to a memory stream using the deprecated IOutputStorage interface and the new ResourceHandler class. The source with-resources.html document and the linked files are in the same directory.

Using IOutputStorage – 24.1.0 and Earlier Versions

The IOutputStorage interface implementation allowed saving HTML to memory streams:

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

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

    // Initialaze an HTML document
    using (var doc = new HTMLDocument(inputPath))
    {
        // Create an instance of the MemoryOutputStorage class and save HTML to memory
        var memoryStorage = new MemoryOutputStorage();
        doc.Save(memoryStorage);
	    memoryStorage.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 following code snippet shows the realization of the IOutputStorage in the MemoryOutputStorage class to demonstrate saving an HTML document to memory streams.

    internal class MemoryOutputStorage : IOutputStorage
    {
        public List<Tuple<OutputStream, string>> Streams;

        public MemoryOutputStorage()
        {
            Streams = new List<Tuple<OutputStream, string>>();
        }

        public OutputStream CreateStream(OutputStreamContext context)
        {
            var normalizedPath = new Url(context.Uri).Pathname;
            var uri = new Url(Path.GetFileName(normalizedPath), "memory:///").Href;
            var outputStream = new OutputStream(new MemoryStream(), uri);
            Streams.Add(Tuple.Create(outputStream, uri));
            return outputStream;
        }

        public void ReleaseStream(OutputStream stream)
        {
            stream.Flush();
        }

        public void PrintInfo()
        {
            foreach (var stream in Streams)
                Console.WriteLine($"uri:{stream.Item2}, length:{stream.Item1.Length}");
        }
    }

Using new ResourceHandler class – Since Version 24.2

The following code snippet shows the realization of the ResourceHandler in the MemoryResourceHandler class to demonstrate saving an HTML document to memory streams:

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

Instead of the CreateStream() and ReleaseStream() methods implemented in the MemoryOutputStorage class of the IOutputStorage interface, there is now one HandleResource() method implemented in the MemoryResourceHandler class of the ResourceHandler class, in which you can create a stream yourself and release it wherever you need it. The new method adds the ability to see a Resource and process more information about it:

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

As you can see, the new approach directly operates with Resource objects, eliminating the need for additional classes such as OutputStream. This simplifies the code and makes interaction with resources more explicit and understandable. Thus, the ResourceHandler base class offers a more simplified and expressive way to handle resources when saving HTML documents to memory streams.

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

Aspose.HTML offers free HTML Web Applications that are an online collection of converters, mergers, SEO tools, HTML code generators, URL tools, and more. The applications work on any operating system with a web browser and do not require any additional software installation. It’s a fast and easy way to efficiently and effectively solve your HTML-related tasks.