Скачать или смотреть How to Load a ResourceDictionary from a Dynamically Loaded Avalonia DLL

Learn how to properly load ResourceDictionaries from XAML files embedded in dynamically loaded Avalonia UI DLLs, with a clean, embedded resource approach and runtime XAML loading.
---
This video is based on the question https://stackoverflow.com/q/79346178/ asked by the user 'cboittin' ( https://stackoverflow.com/u/5078353/ ) and on the answer https://stackoverflow.com/a/79351637/ provided by the user 'cboittin' ( https://stackoverflow.com/u/5078353/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: How do i get a ResourceDictionary from a xaml file in a dynamically loaded DLL

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to drop me a comment under this video.
---
Introduction

When working with Avalonia UI, you might create custom controls in a separate DLL along with their styles and resources defined in XAML files. Loading these dynamically at runtime and applying their styles to your main application can be tricky. Simply referencing StyleInclude or ResourceInclude URIs often leads to errors, especially if precompiled XAML or resource paths are not found.

This post explains a practical approach to dynamically load resource dictionaries from XAML files inside a DLL and merge them into your application's resources.

The Problem

You have a DLL with custom controls.

The DLL contains XAML style and resource files (e.g., DefaultStyles.axaml, DefaultResources.axaml).

You load the DLL dynamically using reflection and Assembly.LoadFile.

Trying to add StyleInclude or ResourceInclude URIs referencing those XAML files results in errors like:

"No precompiled XAML found"

"Resource not found"

Why Does This Happen?

Avalonia expects XAML files referenced by URI (e.g., avares://MyAssembly/DefaultResources.axaml) to:

Be embedded as Avalonia resources,

Have precompiled XAML generated,

Or be located correctly in the runtime resource system,

When loading DLLs dynamically without proper resource embedding or precompilation, these URIs cannot be resolved.

The Solution: Embed XAML as Embedded Resources and Load Manually

Instead of relying on URI-based ResourceInclude, embed your XAML files directly as Embedded Resources inside your DLL:

In your DLL project, set DefaultResources.axaml and DefaultStyles.axaml to use the EmbeddedResource build action.

At runtime, when you load the DLL, extract the embedded XAML streams manually:

[[See Video to Reveal this Text or Code Snippet]]

Here, AvaloniaRuntimeXamlLoader.Load reads the XAML from the stream and creates resource dictionaries or styles correctly, bypassing the URI resolution issues.

Why This Works

The XAML is loaded directly from the DLL's embedded resource stream.

No reliance on precompiled XAML or Avalonia's URI resolver.

Supports truly dynamic loading of controls and their styles/resources.

Summary

To dynamically add resource dictionaries from DLL XAML files in Avalonia:

Embed the XAML files as embedded resources.

Use Assembly.GetManifestResourceStream to access them at runtime.

Load XAML manually using AvaloniaRuntimeXamlLoader.Load.

Add the resulting resource dictionaries to your application's merged dictionaries.

This method is straightforward, reliable, and fits dynamic plugin-like architectures.

Bonus Tips

Ensure your resource names in the DLL match exactly.

Consider naming conventions to find resource names programmatically.

Dispose streams properly to avoid memory leaks.

Using this approach, you can seamlessly integrate styles and resources from dynamically loaded Avalonia UI control libraries.