Loading SVG fonts | .NET

Loading SVG Fonts with Aspose.Font for .NET

Why SVG fonts?

• Scalable vector description – each glyph is defined by an XML <glyph> element (paths, transformations, Unicode mapping).
• Web‑first format – SVG fonts can be embedded directly in HTML/CSS (@font-face) and are supported by most modern browsers.
• Editable – because the data is plain XML you can programmatically tweak glyph outlines or metadata before rendering or converting to another format (TTF/WOFF/OTF).

Aspose.Font provides a single, unified API to load any supported font type (TTF, OTF, WOFF, WOFF2, SVG, …) and work with it as a strongly‑typed Aspose.Font.Font object.

What you need

Item	Description	How to obtain
Aspose.Font for .NET	Core library that reads/writes all supported font formats (including SVG).	dotnet add package Aspose.Font or via the NuGet UI: https://www.nuget.org/packages/Aspose.Font/
Target framework	.NET Framework 4.x / .NET Core 3.x / .NET 5/6/7 – any platform supported by Aspose.Font.	No extra runtime needed.
Namespace imports	csharp<br>using Aspose.Font;<br>using Aspose.Font.Sources;<br>using System.IO;<br>	—

Add the NuGet package

dotnet add package Aspose.Font

Core API Concepts

Class / Enum	Purpose
FontDefinition	Describes what you want to load (font type + source).
FontFileDefinition	Binds a stream source (FileSystemStreamSource, ByteContentStreamSource, etc.) together with the file extension ("svg").
FileSystemStreamSource / ByteContentStreamSource	Provide a readable stream of the underlying bytes – either from a file on disk or from an in‑memory buffer.
Font.Open(FontDefinition)	Factory method that parses the source and returns a concrete Aspose.Font.Font implementation (SvgFont).

The only thing that changes between formats is the FontType enum value (Svg) and the file‑extension string ("svg").

Loading an SVG font – three common scenarios

Loading from the file system

using System;
using System.IO;
using Aspose.Font;
using Aspose.Font.Sources;

class LoadSvgFromFile
{
    static void Main()
    {
        // 1️⃣ Path to the *.svg* file
        string svgPath = @"C:\Fonts\MyWebFont.svg";

        // Verify the file exists
        if (!File.Exists(svgPath))
            throw new FileNotFoundException($"SVG file not found: {svgPath}");

        // 2️⃣ Stream source that reads directly from the file
        FileSystemStreamSource streamSrc = new FileSystemStreamSource(svgPath);

        // 3️⃣ FontFileDefinition – we tell Aspose the extension is "svg"
        FontFileDefinition fileDef = new FontFileDefinition("svg", streamSrc);

        // 4️⃣ FontDefinition – specify the exact font type
        FontDefinition fontDef = new FontDefinition(FontType.Svg, fileDef);

        // 5️⃣ Load the font
        Font svgFont = Font.Open(fontDef);

        Console.WriteLine($"Loaded font: {svgFont.GetType().Name}");   // → SvgFont
    }
}

Result: svgFont is an instance of Aspose.Font.Svg.SvgFont. From here you can query glyphs, metrics, or convert it to another format.

Loading from a byte array

using System;
using System.IO;
using Aspose.Font;
using Aspose.Font.Sources;

class LoadSvgFromBytes
{
    static void Main()
    {
        // Assume the SVG font was bundled as an embedded resource
        byte[] svgBytes = File.ReadAllBytes(@"C:\Fonts\MyWebFont.svg");

        // Wrap the raw bytes into a stream source
        ByteContentStreamSource byteSrc = new ByteContentStreamSource(svgBytes);

        // Build the definition – extension still must be “svg”
        FontDefinition fd = new FontDefinition(
            FontType.Svg,
            "svg",
            byteSrc);

        // Load
        Font svgFont = Font.Open(fd);

        Console.WriteLine($"Glyph count: {((Aspose.Font.Svg.SvgFont)svgFont).Glyphs.Count}");
    }
}

When to use:

• The font is stored inside your assembly as a resource.
• You have downloaded the font via HTTP and already have it in memory.

Loading directly from an open stream

using System;
using System.IO;
using Aspose.Font;
using Aspose.Font.Sources;

class LoadSvgFromOpenStream
{
    static void Main()
    {
        using (FileStream fs = File.OpenRead(@"C:\Fonts\MyWebFont.svg"))
        {
            // The stream source can be constructed from any Stream object
            FileSystemStreamSource src = new FileSystemStreamSource(fs);

            // Pass stream source + extension straight into FontDefinition
            FontDefinition fd = new FontDefinition(
                FontType.Svg,
                "svg",
                src);

            Font svgFont = Font.Open(fd);
            Console.WriteLine($"Family name: {((Aspose.Font.Svg.SvgFont)svgFont).FamilyNames[0]}");
        }
    }
}

Why this matters:
If you already own a Stream (e.g., from an ASP.NET upload) you don’t need to write it to disk first – just wrap it and open.

All of these scenarios are demonstrated in the official examples repository:

Conclusion

With just three lines of code you can pull an SVG font from disk, memory, or any custom stream and instantly gain full programmatic access to its glyph paths, metrics, and conversion capabilities—thanks to Aspose.Font’s unified model. Combine this with Aspose.SVG’s rendering engine if you need to rasterize text directly onto an image or PDF, and you have a complete pipeline for modern web‑centric typography in .NET.