Question

I have a couple different applications where this would be helpful, but for the sake of a concrete example, let us suppose I have a WinForms application.

This application makes use of WPF controls within ElementHost objects. I now would like to define an implicit style for all WPF Buttons (System.Windows.Controls.Button) so that every ElementHost does not need to merge in the resource dictionary nor does every Button need to explicitly specify the style.

Where do I define said style?

I have tried creating the resource dictionary Themes\Generic.xaml in the project root and specifying

[assembly: ThemeInfo(
    ResourceDictionaryLocation.None,
    ResourceDictionaryLocation.SourceAssembly )]

in the AssemblyInfo.cs. This did not work and I am under the impression that that styles there are only for custom controls defined in the same assembly, where as Button is defined in a foreign assembly.

Examples place implicit style code in <Application.Resources>; however, that node is with-in App.xaml, which (the project not having started its life as a WPF application) does not exist. Is it possible to add an App.xaml or is there some other place to put <Application.Resources> such that they are recognized?

Answer 1

Dr WPF has several suggestions:
http://drwpf.com/blog/2007/10/05/managing-application-resources-when-wpf-is-hosted/

Some relevant parts quoted below:

---

Create an Application Instance and Add Resources in Code
Below is a very simple function that will create the Application object if it does not exist and then load some resources:

public static void EnsureApplicationResources()
{
    if (Application.Current == null)
    {
        // create the Application object
        new Application();

        // merge in your application resources
        Application.Current.Resources.MergedDictionaries.Add(
            Application.LoadComponent(
               new Uri("MyLibrary;component/Resources/MyResourceDictionary.xaml",
               UriKind.Relative)) as ResourceDictionary);
    }
}

Now you just need to make sure that you call this function prior to parsing any XAML files that contain static resource references to application-level resources. To do this, simply add a call to the above function in the constructor of your markup-based classes before any call to InitializeComponent():

public Page1()
{
    EnsureApplicationResources();
    InitializeComponent();
}

---

Define the Application Class in XAML and Create It on the Fly
First, we do not want MSBuild to generate an application entry point for our Application class. So instead of declaring the App.xaml file as an ApplicationDefinition element in the project file, we need to declare it as a Page element:

<Page Include="App.xaml" />
<Compile Include="App.xaml.cs">
  <DependentUpon>App.xaml</DependentUpon>
  <SubType>Code</SubType>
</Compile>

Next, we need to make sure that our App.xaml markup is parsed. Typically, this is done as part of the entry point function (which we just eliminated). Instead, we can simply define a constructor for the Application class and call InitializeComponent directly:

public App()
{
    InitializeComponent();
}

Now all our resources and merged dictionaries can be declared in App.xaml and our static function to load the Application instance can be as simple as this:

public static void EnsureApplicationResources()
{
    if (Application.Current == null)
    {
        // create the Application object
        new App();
    }
}

---

Manage a Collection of Resource Dictionaries in Code and Merge them at the Element Level
In this scenario, we do not leverage an Application object at all. Instead, we dynamically load each ResourceDictionary at runtime and selectively merge it into pages or windows or specific elements, as necessary.

public static class SharedResources
{
    public static readonly DependencyProperty MergedDictionariesProperty =
        DependencyProperty.RegisterAttached("MergedDictionaries",
            typeof(string), typeof(SharedResources),
            new FrameworkPropertyMetadata((string)null,
                new PropertyChangedCallback(OnMergedDictionariesChanged)));

    public static string GetMergedDictionaries(DependencyObject d)
    {
        return (string)d.GetValue(MergedDictionariesProperty);
    }

    public static void SetMergedDictionaries(DependencyObject d, string value)
    {
        d.SetValue(MergedDictionariesProperty, value);
    }

    private static void OnMergedDictionariesChanged(DependencyObject d,
        DependencyPropertyChangedEventArgs e)
    {
        if (!string.IsNullOrEmpty(e.NewValue as string))
        {
            foreach (string dictionaryName in (e.NewValue as string).Split(';'))
            {
                ResourceDictionary dictionary = GetResourceDictionary(dictionaryName);
                if (dictionary != null)
                {
                    if (d is FrameworkElement)
                    {
                        (d as FrameworkElement).Resources
                            .MergedDictionaries.Add(dictionary);
                    }
                    else if (d is FrameworkContentElement)
                    {
                        (d as FrameworkContentElement).Resources
                            .MergedDictionaries.Add(dictionary);
                    }
                }
            }
        }
    }

    private static ResourceDictionary GetResourceDictionary(string dictionaryName)
    {
        ResourceDictionary result = null;
        if (_sharedDictionaries.ContainsKey(dictionaryName))
        {
            result = _sharedDictionaries[dictionaryName].Target;
        }
        if (result == null)
        {
            string assemblyName = System.IO.Path.GetFileNameWithoutExtension(
                Assembly.GetExecutingAssembly().ManifestModule.Name);
            result = Application.LoadComponent(new Uri(assemblyName
                + ";component/Resources/" + dictionaryName + ".xaml",
                UriKind.Relative)) as ResourceDictionary;
            _sharedDictionaries[dictionaryName] = new WeakReference(result);
        }
        return result;
    }

    private static Dictionary<string, WeakReference> _sharedDictionaries
        = new Dictionary<string, WeakReference>();
}

This would allow us to merge in shared resource dictionaries to the Resources collection of any framework element, by simply doing this:

<Grid dw:SharedResources.MergedDictionaries="ApplicationBrushes;ButtonStyles">