Sharing WPF-Dictionary from another assembly

Ok, I busting my head on this for few hours now and still cannot find a solution.

first I shall explain the simple test case I created: Solution

- ClassLibrary1
  - Dictionary1.xaml
- WpfApplication3
  - App.config
  - App.xaml
  - Dictionary2.xaml
  - MainWindows.xaml

ClassLibrary1:

That project has the required references to allow me to add wpf-dictionary:
PresentationCore, PresentationFramework, Systam.Xaml, windowsbase
(Along with all standard assemblies for any regular class library)

And this is Dictionary1.xaml:

<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <Color x:Key="PrimaryBackgroundColor">#FF030010</Color>
    <SolidColorBrush x:Key="PrimaryBackgroundBrush" Color="{StaticResource PrimaryBackgroundColor}" />
</ResourceDictionary>

WpfApplication3:

This project just display a button on a wpf-form.

Dictionary2.xaml:

<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                    xmlns:local="clr-namespace:WpfApplication3">
    <ResourceDictionary.MergedDictionaries>
        <ResourceDictionary Source="pack://application:,,,/ClassLibrary1.dll;component/Dictionary1.xaml"/>
    </ResourceDictionary.MergedDictionaries>
    <Style TargetType="Button">
        <Setter Property="Background" Value="{StaticResource PrimaryBackgroundBrush}" />
    </Style>
</ResourceDictionary>

MainWindow.xaml:

<Window x:Class="WpfApplication3.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WpfApplication3"
        mc:Ignorable="d"
        Title="MainWindow" Height="350" Width="525">
    <Window.Resources>
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
                <ResourceDictionary Source="Dictionary2.xaml"/>
            </ResourceDictionary.MergedDictionaries>
        </ResourceDictionary>
    </Window.Resources>
    <Grid>
        <Button Content="aaa" Width="100" Height="40" />
    </Grid>
</Window>

That's all - very simple as you can see.
The only thing here is that dictionary2 need to use resource from dictionary1.

And so there are two ways to reference another assembly:

Option 1: The class-library is a project in your solution and your WpfApplication adds reference to the class library project which is in the same solution. this is done via Add-Reference/Projects, And in that situation all works great.

Option 2: The class-library is not your solution. (actually it can be like in my example) however you add reference by adding reference to ClassLibrary1.Dll which resides either in your bin\debug or bin\release folders. In that situation a portal to hell is opened. Dictionary2 complains it cannot find the resource 'PrimaryBackgroungBrush' and upon execution it crush complaining it cannot find the dictionary1.xaml

Exception thrown: 'System.Windows.Markup.XamlParseException' in PresentationFramework.dll and the inner exception: {"Could not load file or assembly 'ClassLibrary1.dll, Culture=neutral' or one of its dependencies. The system cannot find the file specified.":"ClassLibrary1.dll, Culture=neutral"}

The problem is that using option2 is essential as I want to share the same dictionary among other wpf projects without having the ClassLibrary1 project as part of their solution.

Suggested way to reproduce:

Create a new solution in Visual studio for WPF application.
Add class library project to the solution.
In class libarary project, Add references to the following assemblies: PresentationCore, PresentationFramework, Systam.Xaml, windowsbase
Add Wpf-Dictionary 'Dictionary1' to your class library project and copy the code. (you can copy one from the wpf project since it will not exist as an option in the add item from the class library)
Add Wpf-Dictionary 'Dictionary2' to your wpf application and copy the code.
Copy the code for MainWindow.

And now:

Add reference to class library (as project, from projects tab in add refernce dialog) Build everything - all should work.
Remove the refernce to class library.
Add reference to class library (as dll, from browse tab and find it in your classlibrary/bin/debug or release folder) Build everything - you will notice my problem.

Any solution to this problem?

UPDATE 1

I changed the line in dictionary2.xaml from:
<ResourceDictionary Source="pack://application:,,,/ClassLibrary1.dll;component/Dictionary1.xaml"/>
To:
<ResourceDictionary Source="pack://application:,,,/ClassLibrary1;component/Dictionary1.xaml"/>

And now the project compiles and execute without an error, However while in design time - the xaml view of dictionary2 indicate that it cannot find the resource: 'PrimaryBackgroundBrush` and puts the ugly curly underline below it.
So its a progress - but i'm still not happy with that.
Any ideas how to solve that?

UPDATE 2 As previously stated - everything compiles and execute now.
However what you see in the following picture annoys me,
I just want to be sure that others who added the class library as .Dll file and not as project 100% sure they don't get that problem which can be seen in the picture, meaning their xaml intellisense can recognize the resource during design time.

Solution

I could imagine how documentation about that dll will looks like:

reference dll in the project
add this to resource dictionary in the project:

<ResourceDictionary.MergedDictionaries>
    <ResourceDictionary Source="pack://application:,,,/ClassLibrary1.dll;component/Dictionary1.xaml"/>
</ResourceDictionary.MergedDictionaries>

add this to each window/usercontrol:

<Window.Resources>
    <ResourceDictionary>
        <ResourceDictionary.MergedDictionaries>
            <ResourceDictionary Source="Dictionary2.xaml"/>
        </ResourceDictionary.MergedDictionaries>
    </ResourceDictionary>
</Window.Resources>

Which looks afwul.

How about making manager in your library which has to be referenced by each window/usercontrol and it will do things automatically?

Here is a cut from theme manager I mentioned in comments (it does merging automatically), think about easy of use.

xaml (add this to each window/usercontrol which has to support theme switching in design/run time):

         local:Theme.Theme=""

cs (this part has to be a part of library):

public static class Theme
{
    public static readonly DependencyProperty ThemeProperty =
        DependencyProperty.RegisterAttached("Theme", typeof(string), typeof(Theme), new PropertyMetadata(null, (d, e) =>
        {
            var theme = (string)e.NewValue;
            // in run-time set theme to specified during init
            if (!DesignerProperties.GetIsInDesignMode(d))
                theme = _theme;
            var element = d as FrameworkElement;
            element.Resources.MergedDictionaries.Clear();
            if (!string.IsNullOrEmpty(theme))
            {
                var uri = new Uri($"/MyPorject;component/Themes/{theme}.xaml", UriKind.Relative);
                element.Resources.MergedDictionaries.Add(new ResourceDictionary() { Source = uri });
            }
        }));
    public static string GetTheme(DependencyObject obj) => (string)obj.GetValue(ThemeProperty);
    public static void SetTheme(DependencyObject obj, string value) => obj.SetValue(ThemeProperty, value);

    static string _theme = "Generic";

    static string[] _themes = new[]
    {
        "Test",
    };

    /// <summary>
    /// Init themes
    /// </summary>
    /// <param name="theme">Theme to use</param>
    public static void Init(string theme)
    {
        if (_themes.Contains(theme))
            _theme = theme;
    }
}

P.S.: functionality is primitive (it is sufficient in my case), but should give you an idea.