Guardar un documento SVG – C#

Guardar un documento SVG

La mayoría de las tareas que debe realizar requieren guardar un documento. Una vez que cargue el archivo existente o cree un documento SVG desde cero, puede guardar los cambios utilizando uno de los métodos SVGDocument.Save(). Existen métodos sobrecargados que permiten guardar SVG en un archivo, secuencia, archivo Zip o URL.

En este artículo, revisamos cómo guardar los documentos SVG en el mismo formato. Descubrirá cómo guardar su archivo SVG utilizando los métodos Save() de la clase SVGDocument. Además, Aspose.SVG for .NET proporciona la clase ResourceHandler que permite guardar documentos SVG con recursos para transmitirlos y administrarlos.

Los escenarios de conversión y renderización de SVG a otros formatos se ven en la sección Cómo convertir archivos SVG.

Guardar SVG en un archivo

El siguiente fragmento de código demuestra el uso del método SVGDocument.Save() para guardar un documento SVG en un archivo:

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

Guardar SVG en una URL

Es necesario especificar una ruta URL completa para guardar el documento lineto.svg y pasar el objeto url al método Save() que guarda el documento en un archivo especificado por la URL. El siguiente ejemplo de código muestra cómo guardar un documento en una 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);
    }

Guarde SVG en un almacenamiento del sistema de archivos local

El documento SVG puede contener diferentes recursos como CSS, imágenes y archivos externos. Aspose.SVG proporciona una forma de guardar SVG con todos los archivos vinculados: la clase ResourceHandler está desarrollada para guardar contenido y recursos SVG en transmisiones. Esta clase es responsable de manejar los recursos y proporciona métodos que le permiten controlar lo que se hace con cada recurso.

Consideremos un ejemplo de cómo guardar SVG con recursos en el almacenamiento de archivos local especificado por el usuario. El documento fuente with-resources.svg y su archivo de imagen vinculado están en el mismo directorio. El constructor FileSystemResourceHandler(customOutDir) toma una ruta que indica dónde se guardará el documento con recursos y crea un objeto FileSystemResourceHandler. El método Save(resourceHandler) toma este objeto y guarda SVG en el almacenamiento de salida.

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

Guarde SVG en un archivo Zip

Puede implementar ResourceHandler creando la clase ZipResourceHandler. Le permite crear un archivo estructurado y comprimido que contiene documentos SVG y recursos asociados, lo que lo hace adecuado para escenarios como el archivado y la optimización del almacenamiento. El método HandleResource() en la clase ZipResourceHandler sirve para personalizar el comportamiento de cómo se procesan y almacenan los recursos individuales en un archivo Zip.

En el siguiente ejemplo, la clase ZipResourceHandler se utiliza para guardar el documento with-resources.svg junto con sus recursos vinculados en un archivo Zip:

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

La clase ResourceHandler está destinada a la implementación del cliente. La clase ZipResourceHandler extiende la clase base ResourceHandler y proporciona una manera conveniente de administrar todo el proceso de manejo y almacenamiento de recursos vinculados con un documento SVG en un archivo Zip dentro del contexto de la biblioteca Aspose.SVG for .NET:

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

Guardar SVG en secuencias de memoria

La implementación de la clase ResourceHandler en la clase MemoryResourceHandler permite guardar SVG en flujos de memoria. El siguiente código muestra cómo utilizar la clase MemoryResourceHandler para almacenar un documento SVG en la memoria, recopilando e imprimiendo información sobre los recursos manejados.

1. Inicialice un documento SVG utilizando la ruta del archivo SVG especificada.
2. Cree una instancia de la clase MemoryResourceHandler. Esta clase está diseñada para capturar y almacenar recursos dentro de flujos de memoria durante el proceso de manejo de recursos.
3. Llame al método Save() del documento SVG y pásele la instancia MemoryResourceHandler como argumento. Esto asocia la lógica de manejo de recursos de MemoryResourceHandler con el proceso de guardado de documentos SVG.
4. Utilice el método PrintInfo() de MemoryResourceHandler para imprimir información sobre los recursos manejados.

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

Después de ejecutar el ejemplo, se imprimirá el mensaje sobre el almacenamiento de memoria:

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

ResourceHandler es una clase base que admite la creación y gestión de flujos de salida. La clase MemoryResourceHandler le permite capturar y almacenar flujos de recursos en memoria, proporcionando una forma dinámica y flexible de manejar recursos sin guardarlos físicamente en el sistema de archivos. El siguiente fragmento de código muestra la realización de ResourceHandler en la clase MemoryResourceHandler:

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

Puede descargar los ejemplos completos y los archivos de datos desde GitHub. Encontrará información sobre la descarga desde GitHub y la ejecución de ejemplos en la sección Cómo ejecutar los ejemplos.

Puede intentar convertir documentos SVG a otros formatos con nuestro Convertidor SVG en línea gratuito.