Output Streams – C# MemoryStream

Output Streams – C#

In conversion operations, we normally save the rendering result to the file. However, in some cases, you may need to store the result in memory or send it to remote storage. You can easily do this by implementing the specialized ICreateStreamProvider interface and using it as an input parameter to the converter. This interface represents a callback that uses when a new output stream is required.

Note: It may be invoked a few times when multiple output streams are required. The scenario when this case is possible is rendering HTML to the set of image files.

MemoryStreamProvider class

Aspose.HTML C# library allows realizing the MemoryStreamProvider class as a custom implementation of the ICreateStreamProvider interface. The MemoryStreamProvider class provides C# MemoryStream objects as output streams for writing data, which can be stored in memory as a stream.

Using a C# MemoryStream helps to avoid latencies commonly associated with reading or writing files on a disk. Additionally, because the contents of a MemoryStream stay in memory, physical space on the disk is not utilized. The C# code below is an example of the application that uses ICreateStreamProvider to store the rendering result in memory and flush it to the file later:

using Aspose.Html.IO;
using System.Collections.Generic;
using System.IO;
...
    class MemoryStreamProvider : Aspose.Html.IO.ICreateStreamProvider
    {
        // List of MemoryStream objects created during the document rendering
        public List<MemoryStream> Streams { get; } = new List<MemoryStream>();

        public Stream GetStream(string name, string extension)
        {
            // This method is called when only one output stream is required, for instance for XPS, PDF or TIFF formats
            MemoryStream result = new MemoryStream();
            Streams.Add(result);
            return result;
        }

        public Stream GetStream(string name, string extension, int page)
        {
            // This method is called when the creation of multiple output streams are required. For instance, during the rendering HTML to list of image files (JPG, PNG, etc.)
            MemoryStream result = new MemoryStream();
            Streams.Add(result);
            return result;
        }

        public void ReleaseStream(Stream stream)
        {
            //  Here you can release the stream filled with data and, for instance, flush it to the hard-drive
        }

        public void Dispose()
        {
            // Releasing resources
            foreach (var stream in Streams)
                stream.Dispose();
        }
    }

Let’s look at the main parts of the MemoryStreamProvider class:

1. Streams property. A list of MemoryStream objects is created during the document rendering. These objects will store the data that is written to the output streams.
2. Implementation of the GetStream() methods. GetStream() methods create new MemoryStream objects, add them to the Streams list, and return them as output streams.
3. Implementation of the ReleaseStream() method. The ReleaseStream() method releases a Stream object filled with data. In this implementation, the method is empty. Still, you can customize it to perform operations such as flushing the stream to a hard drive or releasing any resources associated with the stream.
4. Implementation of the Dispose() method. This method is called to release any resources held by the MemoryStreamProvider class. This implementation disposes of all the MemoryStream objects in the Streams list using a foreach loop.

C# MemoryStream to File

The following C# code demonstrates how to use the MemoryStreamProvider class and the Aspose.HTML library to convert a multiple-page HTML document to JPG and save the image to a file. Let’s look at the example where the following steps are performed:

1. Create a new instance of the MemoryStreamProvider class. It will be used as an output stream for the conversion process.
2. Initialize an HTML document using the HTMLDocument class.
3. Use the ImageSaveOptions() constructor to configure the image save options, such as the ImageFormat – JPEG (in this case).
4. Call the ConvertHTML(document, options, provider) method to convert the HTMLDocument object to an image using save options and MemoryStreamProvider.
5. Use the foreach loop to iterate over each MemoryStream object in the Streams property of the streamProvider object. Each MemoryStream represents a page of the converted HTML document.
6. Call the memory.Seek() method on the memory stream to set the position to the beginning. This ensures that the entire content of the stream will be copied to the output file.
7. Use the File.Create() method inside the loop to create an output file for the current page.
8. Use the memory.CopyTo() method to copy the contents of the memory stream to the FileStream object, which represents the output file.
9. After processing each page, the page counter is incremented to keep track of the page number for the output file names.

using Aspose.Html;
using System.IO;
using Aspose.Html.Converters;
using Aspose.Html.Rendering.Image;
using Aspose.Html.Saving;
...
    // Create an instance of MemoryStreamProvider
    using (var streamProvider = new MemoryStreamProvider())
    {
        // Prepare HTML code
        var code = @"<style>
                    div { page-break-after: always; }
                    </style>
                    <div style='border: 1px solid red; width: 300px'>First Page</div>
                    <div style='border: 1px solid red; width: 300px'>Second Page</div>
                    <div style='border: 1px solid red; width: 300px'>Third Page</div>
                  ";
        // Initialize an HTML document from the HTML code
        using var document = new HTMLDocument(code, ".");
        {
            // Convert HTML to Image by using the MemoryStreamProvider
            Converter.ConvertHTML(document, new ImageSaveOptions(ImageFormat.Jpeg), streamProvider);

            // Get access to the memory stream that contains the result data
            var page = 1;
            foreach (var memory in streamProvider.Streams)
            {
                memory.Seek(0, SeekOrigin.Begin);

                // Flush the result data to the output file
                using (FileStream fs = File.Create(Path.Combine(OutputDir, "output_" + page + ".jpg")))
                {
                    memory.CopyTo(fs);
                }
                page++;
            }
        }
    }

Aspose.HTML offers free online Converters for converting HTML, XHTML, MHTML, EPUB, XML and Markdown files to a variety of popular formats. You can easily convert HTML to PDF, HTML to JPG, SVG to PDF, MHTML to PDF, or MD to HTML. Just select a file, choose the format to convert, and you’re done. It’s fast and completely free!