Aspose.SVG for .NET 24.3.0 – Enregistrer un SVG dans un flux

Aspose.SVG for .NET 24.3.0

Dans la version 24.3.0, l’interface IOutputStorage et la classe LocalFileSystemStorage sont obsolètes mais continueront de fonctionner jusqu’à la sortie de la version 24.6.0. Si vous utilisez des versions antérieures d’Aspose.SVG for .NET, nous vous recommandons de mettre à niveau et de migrer vers la nouvelle version, car la version 24.6.0 supprimera ces classes obsolètes.

Deprecated	New
IOutputStorage Interface	ResourceHandler Class
LocalFileSystemStorage Class	FileSystemResourceHandler Class

Le document SVG peut contenir différentes ressources comme du CSS, des images externes et des fichiers. Dans l’article, nous examinerons les cas d’enregistrement de documents SVG avec des ressources pour l’archive Zip, le flux mémoire et le stockage du système de fichiers local. Aspose.SVG for .NET continue de développer et d’améliorer les moyens d’enregistrer les SVG avec tous les fichiers liés. Ici, nous examinerons des exemples d’enregistrement de fichiers à l’aide de classes obsolètes et proposerons des solutions avancées pour implémenter de nouvelles classes.

Classe ResourceHandler vs Interface IOutputStorage

La classe ResourceHandler permet aux développeurs d’implémenter la méthode HandleResource(), dans laquelle vous pouvez créer vous-même un flux et le publier là où vous en avez besoin. La nouvelle méthode ajoute la possibilité de voir une Resource et de traiter plus d’informations à son sujet. Ainsi, en adoptant la classe ResourceHandler, les développeurs peuvent bénéficier d’une approche plus rationalisée et plus expressive de la gestion des ressources, ce qui se traduit par un code plus propre, plus maintenable et plus flexible lors de l’enregistrement de documents SVG.

Enregistrer SVG dans une archive Zip

Ici, nous examinerons un seul et même exemple de sauvegarde du fichier with-resources.svg dans une archive Zip en utilisant une interface IOutputStorage obsolète et une nouvelle classe ResourceHandler.

Utilisation d’IOutputStorage – 24.2.0 et versions antérieures

L’interface IOutputStorage était une interface de base qui prenait en charge la création et la gestion des flux de sortie. Vous pouvez implémenter l’interface IOutputStorage en créant la classe ZipStorage pour enregistrer le SVG avec les ressources dans une archive 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);
        }
    }

L’extrait de code suivant montre la réalisation de IOutputStorage dans la classe ZipStorage pour démontrer l’enregistrement d’un document SVG avec des ressources dans une archive 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();
        }
    }

Utilisation de la nouvelle classe ResourceHandler – Depuis la version 24.3.0

La classe ResourceHandler est destinée à l’implémentation par les clients. L’exemple C# suivant montre comment enregistrer un document SVG avec des ressources dans une archive Zip à l’aide de la classe 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);
        }
    }

L’extrait de code suivant montre la réalisation de ResourceHandler dans la classe ZipResourceHandler pour démontrer l’enregistrement d’un document SVG avec des ressources dans une archive Zip. La méthode HandleResource() de la classe ZipResourceHandler est responsable de la gestion de chaque ressource pendant le processus de sauvegarde lors de la création d’une archive 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();
        }
    }

Enregistrer SVG dans les flux de mémoire

Considérons l’exemple C# d’enregistrement d’un fichier SVG avec des ressources liées dans un flux mémoire en utilisant l’interface obsolète IOutputStorage et la nouvelle classe ResourceHandler. Le document source with-resources.svg et les fichiers image liés se trouvent dans le même répertoire.

Utilisation d’IOutputStorage – 24.2.0 et versions antérieures

L’implémentation de l’interface IOutputStorage a permis d’enregistrer SVG dans les flux mémoire :

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

Après l’exécution de l’exemple, le message concernant le stockage en mémoire sera imprimé:

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

L’extrait de code suivant montre la réalisation de IOutputStorage dans la classe MemoryOutputStorage pour démontrer l’enregistrement d’un document SVG dans des flux de mémoire.

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

Utilisation de la nouvelle classe ResourceHandler – Depuis la version 24.3.0

L’extrait de code suivant montre la réalisation de ResourceHandler dans la classe MemoryResourceHandler pour démontrer l’enregistrement d’un document SVG dans des flux de mémoire:

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

Au lieu des méthodes CreateStream() et ReleaseStream() implémentées dans la classe MemoryOutputStorage de l’interface IOutputStorage, il existe désormais une méthode HandleResource() implémentée dans la classe MemoryResourceHandler de Classe ResourceHandler, dans laquelle vous pouvez créer vous-même un flux et le publier là où vous en avez besoin. La nouvelle méthode ajoute la possibilité de voir une Resource et de traiter plus d’informations à son sujet:

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

Comme vous pouvez le voir, la nouvelle approche fonctionne directement avec les objets Resource, éliminant le besoin de classes supplémentaires telles que OutputStream. Cela simplifie le code et rend l’interaction avec les ressources plus explicite et compréhensible. Ainsi, la classe de base ResourceHandler offre une manière plus simplifiée et plus expressive de gérer les ressources lors de l’enregistrement de documents SVG dans des flux mémoire.

Après l’exécution de l’exemple, le message concernant le stockage en mémoire sera imprimé :

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

Classe FileSystemResourceHandler vs Classe LocalFileSystemStorage

Contrairement à la classe LocalFileSystemStorage, la nouvelle classe FileSystemResourceHandler permet non seulement de sauvegarder les documents et ressources SVG dans le dossier sélectionné mais aussi, grâce aux méthodes de la classe de base ResourceHandler, de contrôler l’écriture des fichiers SVG. des liens dans les fichiers parents vers les fichiers que vous enregistrez.

Enregistrer SVG sur un stockage de système de fichiers local

Ici, nous examinerons le même exemple d’enregistrement du fichier SVG with-resources.svg dans le stockage du système de fichiers local en utilisant la classe obsolète LocalFileSystemStorage et la nouvelle classe FileSystemResourceHandler.

Utilisation de la classe LocalFileSystemStorage – 24.2.0 et versions antérieures

Le document SVG source avec les fichiers image liés se trouvent dans le même répertoire. Le constructeur LocalFileSystemStorage(customOutDir) crée un objet qui est un stockage de système de fichiers. La méthode Save(IOutputStorage) prend cet objet et enregistre SVG dans le stockage de sortie.

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

Utilisation de la classe FileSystemResourceHandler – Depuis la version 24.3.0

La classe FileSystemResourceHandler est une implémentation de la classe ResourceHandler dans Aspose.SVG for .NET. Explicitement conçue pour enregistrer des ressources sur le système de fichiers local, cette classe fournit une solution pratique et extensible pour gérer les ressources lors de l’enregistrement de documents SVG. L’extrait de code suivant illustre l’utilisation de la classe 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));
    }

Le constructeur FileSystemResourceHandler(customOutDir) prend un chemin indiquant où les ressources seront enregistrées et crée un objet FileSystemResourceHandler. La méthode Save(resourceHandler) prend cet objet et enregistre SVG dans le stockage de sortie.

Vous pouvez télécharger les exemples complets et les fichiers de données depuis GitHub. À propos du téléchargement depuis GitHub et de l’exécution d’exemples, vous le découvrirez dans la section Comment exécuter les exemples.

Vous pouvez essayer de convertir des documents SVG vers divers autres formats avec notre Convertisseur SVG en ligne gratuit.