Aspose.SVG for .NET 24.3.0 – guarde un SVG en una secuencia

Aspose.SVG for .NET 24.3.0

En la versión 24.3.0, la interfaz IOutputStorage y la clase LocalFileSystemStorage han quedado obsoletas, pero seguirán funcionando hasta que se lance la versión 24.6.0. Si utiliza versiones anteriores de Aspose.SVG for .NET, le recomendamos que actualice y migre a la nueva versión, ya que la versión 24.6.0 eliminará estas clases obsoletas.

Deprecated	New
IOutputStorage Interface	ResourceHandler Class
LocalFileSystemStorage Class	FileSystemResourceHandler Class

El documento SVG puede contener diferentes recursos como CSS, imágenes externas y archivos. En el artículo, consideraremos los casos para guardar documentos SVG con recursos en un archivo Zip, flujo de memoria y almacenamiento en el sistema de archivos local. Aspose.SVG for .NET continúa desarrollando y mejorando las formas de guardar SVG con todos los archivos vinculados. Aquí veremos ejemplos de cómo guardar archivos usando clases obsoletas y ofreceremos soluciones avanzadas para implementar nuevas clases.

Clase ResourceHandler frente a interfaz IOutputStorage

La clase ResourceHandler permite a los desarrolladores implementar el método HandleResource(), en el que puedes crear una secuencia tú mismo y publicarla donde la necesites. El nuevo método agrega la capacidad de ver un “Recurso” y procesar más información sobre él. Por lo tanto, al adoptar la clase ResourceHandler, los desarrolladores pueden beneficiarse de un enfoque más ágil y expresivo para administrar recursos, lo que resulta en un código más limpio, más fácil de mantener y flexible al guardar documentos SVG.

Guarde SVG en un archivo Zip

Aquí, examinaremos el mismo ejemplo de cómo guardar el archivo with-resources.svg en un archivo Zip usando una interfaz IOutputStorage obsoleta y una nueva clase ResourceHandler.

Uso de IOutputStorage – 24.2.0 y versiones anteriores

La interfaz IOutputStorage era una interfaz básica que admitía la creación y gestión de flujos de salida. Puede implementar la interfaz IOutputStorage creando la clase ZipStorage para guardar SVG con recursos 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/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);
        }
    }

El siguiente fragmento de código muestra la realización de IOutputStorage en la clase ZipStorage para demostrar cómo guardar un documento SVG con recursos en un archivo Zip.

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

Usando la nueva clase ResourceHandler – Desde la versión 24.3.0

La clase ResourceHandler está destinada a la implementación de los clientes. El siguiente ejemplo de C# muestra cómo guardar un documento SVG con recursos en un archivo Zip usando la clase ZipResourceHandler de 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);
        }
    }

El siguiente fragmento de código muestra la realización de ResourceHandler en la clase ZipResourceHandler para demostrar cómo guardar un documento SVG con recursos en un archivo Zip. El método HandleResource() de la clase ZipResourceHandler es responsable de manejar cada recurso durante el proceso de guardado al crear un archivo Zip:

    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

Consideremos el ejemplo de C# de guardar un archivo SVG con recursos vinculados a una secuencia de memoria usando la interfaz obsoleta IOutputStorage y la nueva clase ResourceHandler. El documento fuente with-resources.svg y los archivos de imagen vinculados están en el mismo directorio.

Uso de IOutputStorage: 24.2.0 y versiones anteriores

La implementación de la interfaz IOutputStorage permitió guardar SVG en flujos de memoria:

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

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

El siguiente fragmento de código muestra la realización de IOutputStorage en la clase MemoryOutputStorage para demostrar cómo guardar un documento SVG en flujos de memoria.

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

Usando la nueva clase ResourceHandler – Desde la versión 24.3.0

El siguiente fragmento de código muestra la realización de ResourceHandler en la clase MemoryResourceHandler para demostrar cómo guardar un documento SVG en secuencias de memoria:

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

En lugar de los métodos CreateStream() y ReleaseStream() implementados en la clase MemoryOutputStorage de la interfaz IOutputStorage, ahora hay un método HandleResource() implementado en la clase MemoryResourceHandler de Clase ResourceHandler, en la que puedes crear una secuencia tú mismo y publicarla donde la necesites. El nuevo método agrega la capacidad de ver un “Recurso” y procesar más información sobre él:

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

Como puede ver, el nuevo enfoque opera directamente con objetos Resource, eliminando la necesidad de clases adicionales como OutputStream. Esto simplifica el código y hace que la interacción con los recursos sea más explícita y comprensible. Por lo tanto, la clase base ResourceHandler ofrece una forma más simplificada y expresiva de manejar recursos al guardar documentos SVG en flujos de memoria.

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

Clase FileSystemResourceHandler frente a clase LocalFileSystemStorage

A diferencia de la clase LocalFileSystemStorage, la nueva clase FileSystemResourceHandler le permite no sólo guardar documentos y recursos SVG en la carpeta seleccionada sino también, a través de los métodos de la clase base ResourceHandler, controlar la escritura de enlaces en archivos principales a los archivos que está guardando.

Guarde SVG en un almacenamiento del sistema de archivos local

Aquí, examinaremos el mismo ejemplo de cómo guardar el archivo SVG with-resources.svg en el almacenamiento del sistema de archivos local utilizando la clase obsoleta LocalFileSystemStorage y la nueva clase FileSystemResourceHandler.

Uso de la clase LocalFileSystemStorage: 24.2.0 y versiones anteriores

El documento SVG de origen con los archivos de imagen vinculados se encuentran en el mismo directorio. El constructor LocalFileSystemStorage(customOutDir) crea un objeto que es un almacenamiento del sistema de archivos. El método Save(IOutputStorage) 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/old/");

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

Uso de la clase FileSystemResourceHandler – desde la versión 24.3.0

La clase FileSystemResourceHandler es una implementación de la clase ResourceHandler en Aspose.SVG for .NET. Diseñada explícitamente para ahorrar recursos en el sistema de archivos local, esta clase proporciona una solución conveniente y extensible para administrar recursos al guardar documentos SVG. El siguiente fragmento de código demuestra el uso de la clase FileSystemResourceHandler:

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

El constructor FileSystemResourceHandler(customOutDir) toma una ruta que indica dónde se guardarán los recursos y crea un objeto FileSystemResourceHandler. El método Save(resourceHandler) toma este objeto y guarda SVG en el almacenamiento de salida.

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.