Enregistrer un document SVG – C#

Enregistrer un document SVG

La plupart des tâches que vous devez effectuer nécessitent l’enregistrement d’un document. Une fois que vous avez chargé le fichier existant ou créé un document SVG à partir de zéro, vous pouvez enregistrer vos modifications à l’aide de l’une des méthodes SVGDocument.Save(). Il existe des méthodes surchargées qui permettent d’enregistrer du SVG dans un fichier, un flux, une archive Zip ou une URL.

Dans cet article, nous passons en revue les documents SVG enregistrés au même format. Vous découvrez comment enregistrer votre fichier SVG à l’aide des méthodes Save() de la classe SVGDocument. De plus, Aspose.SVG pour .NET fournit la classe ResourceHandler qui permet de sauvegarder des documents SVG avec des ressources pour les diffuser et de les gérer.

Les scénarios de conversion et de rendu du SVG vers d’autres formats sont visualisés dans la section Comment convertir des fichiers SVG.

Enregistrer SVG dans un fichier

L’extrait de code suivant illustre l’utilisation de la méthode SVGDocument.Save() pour enregistrer un document SVG dans un fichier:

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

Enregistrer SVG dans une URL

Il est nécessaire de spécifier un chemin Url complet pour l’enregistrement du document lineto.svg et de transmettre l’objet url à la méthode Save() qui enregistre le document dans un fichier spécifié par Url. L’exemple de code suivant montre comment enregistrer un document dans une 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);
    }

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

Le document SVG peut contenir différentes ressources comme du CSS, des images et des fichiers externes. Aspose.SVG fournit un moyen de sauvegarder SVG avec tous les fichiers liés – la classe ResourceHandler est développée pour sauvegarder le contenu et les ressources SVG dans des flux. Cette classe est responsable de la gestion des ressources et fournit des méthodes qui vous permettent de contrôler ce qui est fait avec chaque ressource.

Prenons un exemple d’enregistrement de SVG avec des ressources pour le stockage de fichiers local spécifié par l’utilisateur. Le document source with-resources.svg et son fichier image lié se trouvent dans le même répertoire. Le constructeur FileSystemResourceHandler(customOutDir) prend un chemin indiquant où le document avec les ressources sera enregistré et crée un objet FileSystemResourceHandler. La méthode Save(resourceHandler) 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/save/");

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

Enregistrer SVG dans une archive Zip

Vous pouvez implémenter le ResourceHandler en créant la classe ZipResourceHandler. La méthode HandleResource() de la classe ZipResourceHandler sert à personnaliser le comportement de la façon dont les ressources individuelles sont traitées et stockées dans une archive Zip. Il vous permet de créer une archive structurée et compressée contenant des documents SVG et les ressources associées, ce qui la rend adaptée à des scénarios tels que l’archivage et l’optimisation du stockage.

Dans l’exemple suivant, la classe ZipResourceHandler est utilisée pour enregistrer le document with-resources.svg ainsi que ses ressources liées 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/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 classe ResourceHandler est destinée à l’implémentation client. La classe ZipResourceHandler étend la classe de base ResourceHandler et fournit un moyen pratique de gérer l’ensemble du processus de gestion et de stockage des ressources liées à un document SVG dans une archive Zip dans le contexte de la bibliothèque Aspose.SVG pour .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();
        }
    }

Enregistrer SVG dans les flux de mémoire

L’implémentation de la classe ResourceHandler dans la classe MemoryResourceHandler permet d’enregistrer le SVG dans des flux de mémoire. Le code suivant montre comment utiliser la classe MemoryResourceHandler pour stocker un document SVG en mémoire, collectant et imprimant des informations sur les ressources gérées.

1. Initialisez un document SVG en utilisant le chemin de fichier SVG spécifié.
2. Créez une instance de la classe MemoryResourceHandler. Cette classe est conçue pour capturer et stocker des ressources dans des flux de mémoire pendant le processus de gestion des ressources.
3. Appelez la méthode Save() du document SVG et transmettez-lui l’instance MemoryResourceHandler comme argument. Cela associe la logique de gestion des ressources de MemoryResourceHandler au processus de sauvegarde des documents SVG.
4. Utilisez la méthode PrintInfo() de MemoryResourceHandler pour imprimer des informations sur les ressources gérées.

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

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

Le ResourceHandler est une classe de base qui prend en charge la création et la gestion des flux de sortie. La classe MemoryResourceHandler vous permet de capturer et de stocker des flux de ressources en mémoire, offrant ainsi un moyen dynamique et flexible de gérer les ressources sans les enregistrer physiquement dans le système de fichiers. L’extrait de code suivant montre la réalisation de ResourceHandler dans la classe 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}");
        }
    }

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.