Save an SVG Document – C#

Save an SVG document

Most of the tasks, you need to perform, require saving a document. Once you load the existing file or create an SVG document from scratch, you can save your changes using one of SVGDocument.Save() methods. There are overloaded methods that allow saving SVG to a file, stream, Zip archive or Url.

In this article, we review the SVG documents saving to the same format. You find out how to save your SVG file using Save() methods of the SVGDocument class. Moreover, Aspose.SVG for .NET provides the ResourceHandler class that allows save SVG documents with resources to streams and manage them.

The scenarios of converting and rendering SVG to other formats are viewed in the How to Convert SVG Files section.

Save SVG to a File

The following code snippet demonstrates the use of the SVGDocument.Save() method to save an SVG document to a file:

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

    // Prepare a path for an SVG document saving
	string documentPath = Path.Combine(OutputDir, "lineto_out.svg");

    //  Load the SVG document from a file
    using (var document = new SVGDocument(Path.Combine(DataDir, "lineto.svg")))
    {
        // Work with the document

        // Save SVG to the file
        document.Save(documentPath);
    }

Save SVG to a Url

It is necessary to specify a full Url path for the document lineto.svg saving and pass the url object to the Save() method that saves the document to a file specified by Url. The following code example shows how to save a document to a Url:

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

    // Set a full path for an SVG document saving
	var url = new Url(Path.Combine(OutputDir, "lineto_out.svg"), Directory.GetCurrentDirectory());

    //  Load the SVG document from a file
    using (var document = new SVGDocument(Path.Combine(DataDir, "lineto.svg")))
    {
        // Work with the document
        
        // Save SVG to Url
        document.Save(url);
    }

Save SVG to a Local File System Storage

The SVG document can contain different resources like CSS, external images and files. Aspose.SVG provides a way to save SVG with all linked files – the ResourceHandler class is developed for saving SVG 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 SVG with resourses to user-specified local file storage. The source with-resources.svg 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 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/save/");

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

Save SVG to a Zip Archive

You can implement the ResourceHandler by creating ZipResourceHandler class. It allows you to create a structured and compressed archive containing SVG 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.svg document along with its linked 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/save/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 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 SVG document into a Zip archive within the context of the Aspose.SVG for .NET library:

    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

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

1. Initialize an SVG Document using the specified SVG 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 SVG document and pass it the MemoryResourceHandler instance as an argument. This associates the resource handling logic of the MemoryResourceHandler with the SVG document-saving process.
4. Use the PrintInfo() method of the MemoryResourceHandler to print information about the handled resources.

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

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

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.