Is there a pattern for using custom fonts from a class library?

[DanTravison]

I'm trying to create a class library with a shared media transport control want to use a symbol font for the transport controls but I'm stuck on finding the right way to register the font.

Everything I've found shows registering fonts using MauiApp.CreateBuilder(). What's the right way to do this from a class library?

[DanTravison]

FWIW: The solution I came up with is to use IFontCollection.AddEmbeddedResourceFont(assembly, filename, alias).

... In my satellite assembly, I define a FontResource class and statically initialize a list of font resources.
The fonts themselves are added as embedded resources under ../Resources/Fonts. Marking them as MauiFont did not work.

List defaults = new List()
{
new ("Fonts.openSans-regular.ttf", "OpenSansRegular"),
new ("Fonts.openSans-remibold.ttf", "OpenSansSemibold"),
new ("Fonts.materialdesignicons-webfont.ttf", nameof(MaterialDesign))
};
Defaults = defaults;

In the application's MauiProgram...

.ConfigureFonts(fonts =>
{
foreach (FontResource desc in FontResource.Defaults)
{
fonts.AddEmbeddedResourceFont(desc.Assembly, desc.FileName, desc.Alias);
}
}

[sunilsolanki-alight]

I tried the same but not working for me can you provide more detail or sample

[DanTravison]

Since I'm using the same fonts across all applications, I ended up moving the fonts to the assembly containing the FontResource type, set the Build Action to MauiFont, and defined a static IEnumerable property. FontResource.Load enumerates the array and calls font.AddFont(...) or font.AddEmbeddedResourceFont depending on the value of FontResource.Assembly.

NOTE: Since all fonts are now in the satellite assembly, I no longer call AddEmbeddedResourceFont.

In hindsight, it would have been nicer if AddFont had an (Assembly, string, string) overload to support MauiFont from any assembly.

...
public static void Load(IFontCollection fonts, IEnumerable fontResources)
{
Assembly myAssembly = typeof(FontResource).Assembly;
foreach (FontResource desc in fontResources)
{
if (myAssembly.Equals(desc.Assembly))
{
fonts.AddFont(desc.FileName, desc.Alias);
}
else
{
// NOTE: Currently unused.
fonts.AddEmbeddedResourceFont(desc.Assembly, desc.FileName, desc.Alias);
}
}
}
...

In the MauiAppBuilder...

builder.ConfigureFonts(fonts =>
{
FontResource.Load(fonts, FontResource.DefaultFonts);
});

[tbaggett]

@DanTravison I'm also unable to piece together a working solution from what you've shared. Any chance you can share a sample gist or repo?

Many thanks if so, I've spent a couple of hours trying to get this working without success. Thanks!

[matmork]

Try this

In the class library set build action to MauiFont on the the resource and add a "AssemblyInfo.cs" file
[assembly: ExportFont("MaterialIcons-Regular.ttf", Alias = "MaterialIconsRegular")]

Then in the Maui Project:

.ConfigureFonts(fonts =>
{
    fonts.AddFont("MaterialIcons-Regular.ttf", "MaterialIconsRegular");
})

[jonx]

This did the trick for me! Thank you so much @matmork. I was missing the ExportFont tags.

For the record, the whole procedure that works for me to add fonts in a MAUI library is the following:

1. In the library

• Add your fonts into the Resources\Fonts folder of the project, where its build action will automatically be set to MauiFont. Set the action manually if you add them elsewhere.
• Add a AssemblyInfo.cs file that has the font attributes as follow:
  [assembly: ExportFont("FontAwesome5Brands.otf", Alias = "FontAwesomeBrands")]
  [assembly: ExportFont("FontAwesome5Solid.otf", Alias = "FontAwesomeSolid")]
  [assembly: ExportFont("FontAwesome5Regular.otf", Alias = "FontAwesomeRegular")]
  You don't need to use the full path, just the filename.
• Add an AppHostBuilderExtensions.cs with the following code to register the fonts and give them an alias. This is optional because you can just add the fonts from the main app but like that, it's more seamless:

namespace YourNamespace.MAUI
{
    /// <summary>
    /// Generic MAUI extensions for custom fonts.
    /// </summary>
    public static class AppHostBuilderExtensions
    {
        /// <summary>
        /// Configures fonts for the MAUI application.
        /// </summary>
        /// <param name="builder">The MAUI application builder.</param>
        /// <returns>Configured MAUI app builder with custom settings.</returns>
        public static MauiAppBuilder UseCustomFonts(this MauiAppBuilder builder)
        {
            builder.ConfigureFonts(fonts =>
            {
                fonts.AddFont("FontAwesome5Brands.otf", "FontAwesomeBrands");
                fonts.AddFont("FontAwesome5Solid.otf", "FontAwesomeSolid");
                fonts.AddFont("FontAwesome5Regular.otf", "FontAwesomeRegular");
            });

            return builder;
        }
    }
}

• I also like to add a helper that lets me use nice text instead of Unicode codes (I only add those I will use):

namespace YourNamespace.MAUI.Resources
{
    /// <summary>
    /// Simplified list of FontAwesome icons used in the project.
    /// Each constant represents a FontAwesome icon's Unicode value.
    /// </summary>
    public static class FontAwesomeIcons
    {
        /// <summary>
        /// Gets the Unicode character for the FontAwesome Chromecast icon.
        /// </summary>
        public const string Chromecast = "\uf838";

        /// <summary>
        /// Gets the Unicode character for the FontAwesome Play icon.
        /// </summary>
        public const string Play = "\uf04b";

2. In your MAUI App

• In MauiProgram.cs, call your helper that registers the fonts:

public static MauiApp CreateMauiApp()
        {
            var builder = MauiApp.CreateBuilder();
            builder
                .UseMauiApp<App>()
                .UseCustomFonts();

3. In your XAML

• Add the namespace: xmlns:fontAwesome="clr-namespace:YourNamespace.MAUI.Resources"
• Use it like that:

    FontFamily="FontAwesomeBrands"
    Text="{x:Static fontAwesome:FontAwesomeIcons.Chromecast}"
/>

This also works to add icons to buttons. No need to use an ImageButton's Glyph property. Just the text of your button will do.

[DanTravison]

I guess I completely missed the point of your approach. On re-reading it, found found it much simpler.

FYI: For encapsulation, you don't need an AssemblyInfo.cs file; you can place the FontExport statement at the top of the file containing the builder extension or the helper class file.

The pattern I use is to use the name of the helper class as the font alias and place it in the Resources folder. The builder extension then looks like the following:

[assembly: ExportFont("customfont.ttf", Alias = nameof(MyNamespace.Resources.CustomFont))]

public static MauiAppBuilder UseCustomFont(this MauiAppBuilder builder)
{
    builder.ConfigureFonts(delegate (IFontCollection fonts)
    {
        fonts.AddFont("customfont.ttf", nameof(CustomFont));
    });
    return builder;
}

[DanTravison]

I've created at sample app at FontResource.

I'm building it explicitly against 7.0.92 and no longer see any issues with loading the fonts from the main application and the shared assembly. In fact, I don't appear to need an assembly:FontExport or AddEmbeddedResourceFont. Perhaps something in Maui has changed since I originally tried to have fonts span multiple assemblies.

For the sample, FontResource defines a static IEnumerable DefaultFonts property which defines in the Shared assembly. The main assembly merges the defaults with the font it defined - see the MainProgram.Fonts property.

Within MainProgram.CreateMauiBuilder, I pass the merged IEnumerable to FontResource.Load.

...
.ConfigureFonts(fonts =>
{
FontResource.Load(fonts, Fonts);
});
...

In practice, I use the same fonts in all of my apps so I define them all in the shared assembly.

[tbaggett]

Thanks again so much for providing the sample, @DanTravison!

One thing I didn't consider when reading your original info was the version of MAUI you were using. I'm just starting to convert a Xamarin Forms app to MAUI, and I'm targeting the .NET 8 RC builds, starting with RC 1 and now RC 2. I will build your project with it targeting the RC 2 build and see if it works.

[Visualcoach]

I found an easy way to do this somewhere else. I just add it for whoever stumbles over this question and answers here(like me)

Just put your font in the class library project in some folder.
Manualy change it to 'MauiFont' in the properties window.
Add the fonts names to the Mauiprogramm.cs just like the present default fonts.
You might as well move the default fonts too.

Original source: https://learn.microsoft.com/en-us/answers/questions/1011112/share-fonts-in-maui