Laden von SVG-Schriften | .NET

Laden von SVG-Schriften mit Aspose.Font für .NET

Warum SVG-Schriften?

Skalierbare Vektorbeschreibung – jedes Glyph wird durch ein XML <glyph>‑Element definiert (Pfade, Transformationen, Unicode‑Zuordnung).
Web‑first-Format – SVG‑Schriften können direkt in HTML/CSS (@font-face) eingebettet werden und werden von den meisten modernen Browsern unterstützt.
Bearbeitbar – da die Daten einfaches XML sind, können Sie Glyph‑Konturen oder Metadaten programmatisch anpassen, bevor Sie rendern oder in ein anderes Format konvertieren (TTF/WOFF/OTF).

Aspose.Font bietet eine einheitliche API, um jeden unterstützten Schrifttyp zu laden (TTF, OTF, WOFF, WOFF2, SVG, …) und ihn als stark typisiertes Aspose.Font.Font‑Objekt zu verwenden.

Was Sie benötigen

Element	Beschreibung	Wie zu erhalten
Aspose.Font für .NET	Kernbibliothek, die alle unterstützten Schriftformate liest/schreibt (inklusive SVG).	`dotnet add package Aspose.Font` oder über die NuGet‑Benutzeroberfläche: https://www.nuget.org/packages/Aspose.Font/
Target framework	.NET Framework 4.x / .NET Core 3.x / .NET 5/6/7 – jede Plattform, die von Aspose.Font unterstützt wird.	Keine zusätzliche Laufzeit erforderlich.
Namespace imports	`csharp<br>using Aspose.Font;<br>using Aspose.Font.Sources;<br>using System.IO;<br>`	—

NuGet-Paket hinzufügen

1dotnet add package Aspose.Font

Kern‑API‑Konzepte

Klasse / Aufzählung	Zweck
`FontDefinition`	Beschreibt was Sie laden möchten (Schrifttyp + Quelle).
`FontFileDefinition`	Verbindet eine Stream‑Quelle (`FileSystemStreamSource`, `ByteContentStreamSource`, etc.) mit der Dateierweiterung (`"svg"`).
`FileSystemStreamSource` / `ByteContentStreamSource`	Stellt einen lesbaren Stream der zugrunde liegenden Bytes bereit – entweder von einer Datei auf dem Datenträger oder aus einem Speicherpuffer.
`Font.Open(FontDefinition)`	Fabrikmethode, die die Quelle analysiert und eine konkrete Implementierung von `Aspose.Font.Font` zurückgibt (`SvgFont`).

Das Einzige, was sich zwischen den Formaten ändert, ist der FontType‑Enum‑Wert (Svg) und die Dateierweiterungs‑Zeichenkette ("svg").

Laden einer SVG‑Schrift – drei gängige Szenarien

Laden aus dem Dateisystem

 1using System;
 2using System.IO;
 3using Aspose.Font;
 4using Aspose.Font.Sources;
 5
 6class LoadSvgFromFile
 7{
 8    static void Main()
 9    {
10        // 1️⃣ Pfad zur *.svg*‑Datei
11        string svgPath = @"C:\Fonts\MyWebFont.svg";
12
13        // Prüfen, ob die Datei existiert
14        if (!File.Exists(svgPath))
15            throw new FileNotFoundException($"SVG file not found: {svgPath}");
16
17        // 2️⃣ Stream‑Quelle, die direkt aus der Datei liest
18        FileSystemStreamSource streamSrc = new FileSystemStreamSource(svgPath);
19
20        // 3️⃣ FontFileDefinition – wir teilen Aspose mit, dass die Erweiterung "svg" ist
21        FontFileDefinition fileDef = new FontFileDefinition("svg", streamSrc);
22
23        // 4️⃣ FontDefinition – genauen Schrifttyp angeben
24        FontDefinition fontDef = new FontDefinition(FontType.Svg, fileDef);
25
26        // 5️⃣ Schrift laden
27        Font svgFont = Font.Open(fontDef);
28
29        Console.WriteLine($"Loaded font: {svgFont.GetType().Name}");   // → SvgFont
30    }
31}

Ergebnis: svgFont ist eine Instanz von Aspose.Font.Svg.SvgFont. Von hier aus können Sie Glyphen, Metriken abfragen oder in ein anderes Format konvertieren.

Laden aus einem Byte‑Array

 1using System;
 2using System.IO;
 3using Aspose.Font;
 4using Aspose.Font.Sources;
 5
 6class LoadSvgFromBytes
 7{
 8    static void Main()
 9    {
10        // Angenommen, die SVG‑Schrift wurde als eingebettete Ressource bereitgestellt
11        byte[] svgBytes = File.ReadAllBytes(@"C:\Fonts\MyWebFont.svg");
12
13        // Rohbytes in eine Stream‑Quelle verpacken
14        ByteContentStreamSource byteSrc = new ByteContentStreamSource(svgBytes);
15
16        // Definition erstellen – die Erweiterung muss weiterhin „svg“ sein
17        FontDefinition fd = new FontDefinition(
18            FontType.Svg,
19            "svg",
20            byteSrc);
21
22        // Laden
23        Font svgFont = Font.Open(fd);
24
25        Console.WriteLine($"Glyph count: {((Aspose.Font.Svg.SvgFont)svgFont).Glyphs.Count}");
26    }
27}

Wann zu verwenden:

Die Schrift ist als Ressource in Ihrer Assembly eingebettet.
Sie haben die Schrift per HTTP heruntergeladen und bereits im Speicher.

Laden direkt aus einem offenen Stream

 1using System;
 2using System.IO;
 3using Aspose.Font;
 4using Aspose.Font.Sources;
 5
 6class LoadSvgFromOpenStream
 7{
 8    static void Main()
 9    {
10        using (FileStream fs = File.OpenRead(@"C:\Fonts\MyWebFont.svg"))
11        {
12            // Die Stream‑Quelle kann aus jedem Stream‑Objekt erstellt werden
13            FileSystemStreamSource src = new FileSystemStreamSource(fs);
14
15            // Extension und Stream‑Quelle direkt in FontDefinition übergeben
16            FontDefinition fd = new FontDefinition(
17                FontType.Svg,
18                "svg",
19                src);
20
21            Font svgFont = Font.Open(fd);
22            Console.WriteLine($"Family name: {((Aspose.Font.Svg.SvgFont)svgFont).FamilyNames[0]}");
23        }
24    }
25}

Warum das wichtig ist:
Wenn Sie bereits einen Stream besitzen (z. B. von einem ASP.NET‑Upload), müssen Sie ihn nicht zuerst auf die Festplatte schreiben – einfach einwickeln und öffnen.

Alle diese Szenarien werden im offiziellen Beispiels‑Repository demonstriert:

Fazit

Mit nur drei Codezeilen können Sie eine SVG‑Schrift von der Festplatte, aus dem Speicher oder einem beliebigen benutzerdefinierten Stream laden und sofort vollständigen programmatischen Zugriff auf deren Glyphenpfade, Metriken und Konvertierungsmöglichkeiten erhalten – dank des einheitlichen Modells von Aspose.Font. Kombinieren Sie dies mit der Rendering‑Engine von Aspose.SVG, wenn Sie Text direkt auf ein Bild oder PDF rasterisieren müssen, und Sie haben eine komplette Pipeline für moderne, web‑zentrierte Typografie in .NET.

Laden von Type-1-Schriftarten Schriftartkonverter