Aspose.SVG for .NET 24.3.0 – Save an SVG to a Stream

Aspose.SVG for .NET 24.3.0

In version 24.3.0, the IOutputStorage interface and LocalFileSystemStorage class have been deprecated but will continue to work until version 24.6.0 is released. If you use earlier versions of Aspose.SVG for .NET, we recommend that you upgrade and migrate to the new version, as version 24.6.0 will remove these deprecated classes.

Deprecated	New
IOutputStorage Interface	ResourceHandler Class
LocalFileSystemStorage Class	FileSystemResourceHandler Class

The SVG document can contain different resources like CSS, external images, and files. In the article, we will consider the cases for saving SVG documents with resources to Zip archive, memory stream, and local file system storage. Aspose.SVG for .NET continues to develop and enhance the ways to save SVGs 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 SVG documents.

Save SVG to a Zip Archive

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

Using IOutputStorage – 24.2.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 SVG with resources to a Zip archive:

using System.IO;
using Aspose.Svg.IO;
using System.IO.Compression;
...

	// Prepare a path to a source SVG file 
    string inputPath = Path.Combine(DataDir, "with-resources.svg");;
    
    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 SVG document 
    using (var doc = new SVGDocument(inputPath))
    {
        // Initialize an instance of the ZipStorage class
        using (var zipSrorage = new ZipStorage(customArchivePath))
        {
            // Save SVG 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 SVG 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.3.0

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

using System.IO;
using Aspose.Svg.IO;
using System.IO.Compression;
...

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

    var dir = Directory.GetCurrentDirectory();

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

    // Load an SVG document 
    using (var doc = new SVGDocument(inputPath))
    {
        // Initialize an instance of the ZipResourceHandler class
        using (var resourceHandler = new ZipResourceHandler(customArchivePath))
        {
            // Save SVG 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 SVG 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 SVG to Memory Streams

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

Using IOutputStorage – 24.2.0 and Earlier Versions

The IOutputStorage interface implementation allowed saving SVG to memory streams:

using System.IO;
using Aspose.Svg.IO;
using System.Collections.Generic;
...

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

    // Initialaze an SVG document
    using (var doc = new SVGDocument(inputPath))
    {
        // Create an instance of the MemoryOutputStorage class and save SVG 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.svg, length:556
uri:memory:///photo.png, length:57438

The following code snippet shows the realization of the IOutputStorage in the MemoryOutputStorage class to demonstrate saving an SVG 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.3.0

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

using System.IO;
using Aspose.Svg.IO;
using System.Collections.Generic;
...

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

    // Initialize an SVG document
    using (var doc = new SVGDocument(inputPath))
    {
        // Create an instance of the MemoryResourceHandler class and save SVG 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 SVG documents to memory streams.

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

uri:memory:///with-resources.svg, length:556
uri:memory:///photo.png, length:57438

FileSystemResourceHandler Class Vs LocalFileSystemStorage Class

Unlike the LocalFileSystemStorage class, the new FileSystemResourceHandler class allows you not only to save SVG documents and resources to the selected folder but also, through the methods of the ResourceHandler base class, to control the writing of links in parent files to the files you are saving.

Save SVG to a Local File System Storage

Here, we will examine the same example of saving the SVG file with-resources.svg to local file system storage using the deprecated LocalFileSystemStorage class and the new FileSystemResourceHandler class.

Using LocalFileSystemStorage Class – 24.2.0 and Earlier Versions

The source SVG document with the linked image files are in the same directory. The LocalFileSystemStorage(customOutDir) constructor creates an object that is a file system storage. The Save(IOutputStorage) method takes this object and saves SVG to the output storage.

using System.IO;
using Aspose.Svg.IO;
...

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

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

    // Load the SVG document from a file
    using (var doc = new SVGDocument(inputPath))
    {
        // Save SVG with resources
        doc.Save(new LocalFileSystemStorage(customOutDir));
    }

Using FileSystemResourceHandler Class – Since Version 24.3.0

The FileSystemResourceHandler class is an implementation of the ResourceHandler class in Aspose.SVG for .NET. Explicitly designed for saving resources to the local file system, this class provides a convenient and extensible solution for managing resources when saving SVG documents. The following code snippet demonstrates the use of the FileSystemResourceHandler class:

using System.IO;
using Aspose.Svg.IO;
...

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

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

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

The FileSystemResourceHandler(customOutDir) constructor takes a path indicating where the resources will be saved and creates a FileSystemResourceHandler object. The Save(resourceHandler) method takes this object and saves SVG to the output storage.

You can download the complete examples and data files from GitHub. About downloading from GitHub and running examples, you find out from the How to Run the Examples section.

You can try to convert SVG documents to various other formats with our Free Online SVG Converter.