Aspose.SVG for .NET 24.3.0 – Speichern Sie SVG in einem Stream

Aspose.SVG for .NET 24.3.0

In Version 24.3.0 sind die Schnittstelle IOutputStorage und die Klasse LocalFileSystemStorage veraltet, funktionieren aber weiterhin, bis Version 24.6.0 veröffentlicht wird. Wenn Sie frühere Versionen von Aspose.SVG for .NET verwenden, empfehlen wir Ihnen ein Upgrade und eine Migration auf die neue Version, da Version 24.6.0 diese veralteten Klassen entfernt.

Deprecated	New
IOutputStorage Interface	ResourceHandler Class
LocalFileSystemStorage Class	FileSystemResourceHandler Class

Das SVG-Dokument kann verschiedene Ressourcen wie CSS, externe Bilder und Dateien enthalten. In dem Artikel betrachten wir die Fälle zum Speichern von SVG-Dokumenten mit Ressourcen im Zip-Archiv, im Speicherstream und im lokalen Dateisystemspeicher. Aspose.SVG for .NET entwickelt und verbessert die Möglichkeiten zum Speichern von SVGs mit allen verknüpften Dateien weiter. Hier sehen wir uns Beispiele für das Speichern von Dateien mithilfe veralteter Klassen an und bieten erweiterte Lösungen für die Implementierung neuer Klassen an.

ResourceHandler-Klasse vs IOutputStorage-Schnittstelle

Mit der Klasse ResourceHandler können Entwickler die Methode HandleResource() implementieren, mit der Sie selbst einen Stream erstellen und ihn überall dort freigeben können, wo Sie ihn benötigen. Die neue Methode bietet die Möglichkeit, eine Resource anzuzeigen und weitere Informationen darüber zu verarbeiten. Durch die Einführung der ResourceHandler-Klasse können Entwickler also von einem schlankeren und ausdrucksstärkeren Ansatz zur Ressourcenverwaltung profitieren, was zu saubererem, besser wartbarem und flexiblem Code beim Speichern von SVG-Dokumenten führt.

Speichern Sie SVG in einem Zip-Archiv

Hier untersuchen wir ein und dasselbe Beispiel für das Speichern der Datei with-resources.svg in einem Zip-Archiv unter Verwendung einer veralteten IOutputStorage-Schnittstelle und einer neuen ResourceHandler-Klasse.

Verwenden von IOutputStorage – 24.2.0 und frühere Versionen

Die Schnittstelle IOutputStorage war eine Basisschnittstelle, die die Erstellung und Verwaltung von Ausgabeströmen unterstützte. Sie können die IOutputStorage-Schnittstelle implementieren, indem Sie die Klasse ZipStorage erstellen, um SVG mit Ressourcen in einem Zip-Archiv zu speichern:

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

Der folgende Codeausschnitt zeigt die Realisierung von IOutputStorage in der Klasse ZipStorage, um das Speichern eines SVG-Dokuments mit Ressourcen in einem Zip-Archiv zu demonstrieren.

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

Verwendung der neuen ResourceHandler-Klasse – seit Version 24.3.0

Die Klasse ResourceHandler ist für die Kundenimplementierung vorgesehen. Das folgende C#-Beispiel zeigt, wie man ein SVG-Dokument mit Ressourcen mithilfe der ZipResourceHandler-Klasse des ResourceHandler in einem Zip-Archiv speichert:

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

Der folgende Codeausschnitt zeigt die Realisierung des ResourceHandler in der Klasse ZipResourceHandler, um das Speichern eines SVG-Dokuments mit Ressourcen in einem Zip-Archiv zu demonstrieren. Die Methode HandleResource() der Klasse ZipResourceHandler ist für die Handhabung jeder Ressource während des Speichervorgangs beim Erstellen eines Zip-Archivs verantwortlich:

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

Speichern Sie SVG in Memory Streams

Betrachten wir das C#-Beispiel zum Speichern einer SVG-Datei mit verknüpften Ressourcen in einem Speicherstream mithilfe der veralteten Schnittstelle IOutputStorage und der neuen Klasse ResourceHandler. Das Quelldokument with-resources.svg und die verknüpften Bilddateien befinden sich im selben Verzeichnis.

Verwenden von IOutputStorage – 24.2.0 und frühere Versionen

Die Schnittstellenimplementierung IOutputStorage ermöglichte das Speichern von SVG in Speicherstreams:

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

Nach dem Beispiellauf wird die Meldung zur Speicherbelegung ausgegeben:

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

Der folgende Codeausschnitt zeigt die Realisierung von IOutputStorage in der Klasse MemoryOutputStorage, um das Speichern eines SVG-Dokuments in Speicherstreams zu demonstrieren.

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

Verwendung der neuen ResourceHandler-Klasse – seit Version 24.3.0

Der folgende Codeausschnitt zeigt die Realisierung des ResourceHandler in der Klasse MemoryResourceHandler, um das Speichern eines SVG-Dokuments in Speicherstreams zu demonstrieren:

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

Anstelle der Methoden CreateStream() und ReleaseStream(), die in der Klasse MemoryOutputStorage der Schnittstelle IOutputStorage implementiert sind, gibt es jetzt eine Methode HandleResource(), die in der Klasse MemoryResourceHandler der Schnittstelle ResourceHandler-Klasse, in der Sie selbst einen Stream erstellen und ihn dort freigeben können, wo Sie ihn benötigen. Die neue Methode bietet die Möglichkeit, eine Resource anzuzeigen und weitere Informationen darüber zu verarbeiten:

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

Wie Sie sehen, arbeitet der neue Ansatz direkt mit Resource-Objekten, sodass keine zusätzlichen Klassen wie OutputStream erforderlich sind. Dies vereinfacht den Code und macht die Interaktion mit Ressourcen expliziter und verständlicher. Daher bietet die Basisklasse ResourceHandler eine einfachere und ausdrucksstärkere Möglichkeit, Ressourcen beim Speichern von SVG-Dokumenten in Speicherstreams zu verwalten.

Nach dem Beispiellauf wird die Meldung zur Speicherbelegung ausgegeben:

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

FileSystemResourceHandler-Klasse vs LocalFileSystemStorage-Klasse

Im Gegensatz zur LocalFileSystemStorage-Klasse können Sie mit der neuen Klasse FileSystemResourceHandler nicht nur SVG-Dokumente und -Ressourcen im ausgewählten Ordner speichern, sondern über die Methoden der Basisklasse ResourceHandler auch deren Schreiben steuern Links in übergeordneten Dateien zu den Dateien, die Sie speichern.

Speichern Sie SVG in einem lokalen Dateisystemspeicher

Hier untersuchen wir das gleiche Beispiel des Speicherns der SVG-Datei with-resources.svg im lokalen Dateisystemspeicher unter Verwendung der veralteten Klasse LocalFileSystemStorage und der neuen Klasse FileSystemResourceHandler.

Verwenden der LocalFileSystemStorage-Klasse – 24.2.0 und frühere Versionen

Das Quell-SVG-Dokument mit den verknüpften Bilddateien befindet sich im selben Verzeichnis. Der Konstruktor LocalFileSystemStorage(customOutDir) erstellt ein Objekt, das ein Dateisystemspeicher ist. Die Methode Save(IOutputStorage) nimmt dieses Objekt und speichert SVG im Ausgabespeicher.

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

Verwendung der FileSystemResourceHandler-Klasse – seit Version 24.3.0

Die Klasse FileSystemResourceHandler ist eine Implementierung der Klasse ResourceHandler in Aspose.SVG for .NET. Diese Klasse wurde explizit zum Speichern von Ressourcen im lokalen Dateisystem entwickelt und bietet eine praktische und erweiterbare Lösung für die Ressourcenverwaltung beim Speichern von SVG-Dokumenten. Der folgende Codeausschnitt demonstriert die Verwendung der Klasse 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));
    }

Der Konstruktor FileSystemResourceHandler(customOutDir) verwendet einen Pfad, der angibt, wo die Ressourcen gespeichert werden, und erstellt ein FileSystemResourceHandler-Objekt. Die Methode Save(resourceHandler) nimmt dieses Objekt und speichert SVG im Ausgabespeicher.

Sie können die vollständigen Beispiele und Datendateien von GitHub herunterladen. Informationen zum Herunterladen von GitHub und zum Ausführen von Beispielen finden Sie im Abschnitt So führen Sie die Beispiele aus.

Sie können versuchen, SVG-Dokumente mit unserem Kostenlosen Online-SVG-Konverter in verschiedene andere Formate zu konvertieren.