There are numerous scenarios—especially in branding-sensitive applications—where maintaining visual consistency is crucial. One common case is dynamically generating images (e.g., promotional banners, personalized certificates, or social media visuals) with overlay text that must use a specific custom font tied to brand identity. However, many brand fonts are not standard system-installed fonts, which poses a challenge.

In such situations, you need to dynamically load a custom .ttf or .otf font file at runtime. .NET provides a way to accomplish this using the PrivateFontCollection class from System.Drawing.Text. This allows you to render text in your desired font without requiring a system-wide installation. Still, this method comes with platform-specific limitations (especially in non-Windows or ASP.NET Core environments) and requires careful handling of font file paths and memory resources.

So, what do you do when the brand font isn’t available as a standard system font? You import it on the fly—ensuring both branding consistency and application flexibility.

Here’s a C# solution to import & use a custom Font file.

using System;
using System.Drawing;
using System.Drawing.Text;
using System.IO;
using System.Reflection;

public static class FontHandler
{
    ///
    /// Reads a TTF font file from a file path or stream and returns a custom Font object.
    /// 
    ///Stream of the TTF font file (can be from file or embedded resource)
    ///Desired font size
    ///Font style (e.g., Regular, Bold)
    /// Custom Font object or fallback font on error
    public static Font GetCustomFont(Stream fontStream, float fontSize, FontStyle fontStyle)
    {
        try
        {
            PrivateFontCollection pfc = new PrivateFontCollection();

            // Create temp file to load font
            string tempFontPath = Path.GetTempFileName();
            using (FileStream fs = new FileStream(tempFontPath, FileMode.Create, FileAccess.Write))
            {
                fontStream.CopyTo(fs);
            }

            pfc.AddFontFile(tempFontPath);
            return new Font(pfc.Families[0], fontSize, fontStyle);
        }
        catch (Exception ex)
        {
            // Log error appropriately in production
            Console.WriteLine("Font load error: " + ex.Message);
            return new Font("Arial", fontSize, fontStyle); // Fallback font
        }
    }

    ///
    /// Overload to load font with default FontStyle.Regular
    /// 
    public static Font GetCustomFont(Stream fontStream, float fontSize)
    {
        return GetCustomFont(fontStream, fontSize, FontStyle.Regular);
    }
}

How to Use:

Option 1: Load from File

using (FileStream fs = File.OpenRead("path/to/font.ttf"))
{
    Font customFont = FontHandler.GetCustomFont(fs, 14f);
}

var assembly = Assembly.GetExecutingAssembly();
using (Stream stream = assembly.GetManifestResourceStream("YourNamespace.Fonts.YourFont.ttf"))
{
    Font customFont = FontHandler.GetCustomFont(stream, 14f);
}

Conclusion

This approach gives you flexibility and portability, ensuring that your application can maintain brand typography without relying on system fonts. If you’re deploying to non-Windows environments or cloud platforms, consider switching to SkiaSharp or ImageSharp for modern, cross-platform image manipulation and font rendering.