Impossible to embed WPFToolkit into my executable? - wpf

Question

I made a post about this a while back and got no solutions that worked.
No one said it wasn't possible but some people suggested that the error was coming from something else.
So I created a new solution, simple, just added a toolkit control which calls the DLL via the XAML (namespace import) - which I think is the problem.
I added some code to load the DLL's which I have embedded as resources.
my project can be downloaded from here:
https://onedrive.live.com/redir?resid=B293BA834310C42A%21108
for those who don't have time, here's the code:
MainWindow.xaml:
<Window
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:chartingToolkit="clr-namespace:System.Windows.Controls.DataVisualization.Charting;assembly=System.Windows.Controls.DataVisualization.Toolkit" x:Class="WpfAppTest1.MainWindow"
Title="MainWindow" Height="350" Width="525">
<Grid>
<chartingToolkit:ScatterSeries HorizontalAlignment="Left" Margin="63,85,0,0" VerticalAlignment="Top"/>
</Grid>
</Window>
MainWindow.xaml.cs
namespace WpfAppTest1
{
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
}
}
}
and my App.xaml.cs
namespace WpfAppTest1
{
/// <summary>
/// Interaction logic for App.xaml
/// </summary>
public partial class App : Application
{
public App()
{
AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve);
}
private static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
{
var execAssembly = Assembly.GetExecutingAssembly();
string resourceName = execAssembly.FullName.Split(',').First() + ".Resources." + new AssemblyName(args.Name).Name + ".dll";
Console.WriteLine(resourceName);
using (var stream = execAssembly.GetManifestResourceStream(resourceName))
{
byte[] assemblyData = new byte[stream.Length];
stream.Read(assemblyData, 0, assemblyData.Length);
return Assembly.Load(assemblyData);
}
}
}
}
The 2 DLL's are:
system.windows.controls.datavisualization.toolkit.dll
WPFToolkit.dll
Both are added as Resources and build action is set to Embedded Resource.
The 2 references are copy local to False.
Looking at the EXE, both files are well built into it.
I added a console writeline to print out the path of the DLL being loaded...
But I still get an error. If I do set the copy local to true, it works.
I am really stuck there and have to use this toolkit and I need the DLL to be part of the EXE. If it's not possible then I'd like to read it from one of you pro's :)
thanks
Steve
edit: Is there no solution to achieve what I need? :(
edit: I still haven't found a solution as of today :/
edit: I wonder if this is even possible.

Answer 1

After quite a bit of effort I seem to have this working.
As your resource for system.windows.controls.datavisualization.toolkit is all in lower case, ensure all of the XAML references to it are also, e.g.:
xmlns:chartingToolkit="clr-namespace:System.Windows.Controls.DataVisualization.Charting;assembly=system.windows.controls.datavisualization.toolkit"
This ensures Assembly.GetManifestResourceStream is able to find the resource without any casing issues.
Then change your assembly resolve method to be the following:
private static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
{
var requestedAssemblyName = new AssemblyName(args.Name).Name;
const string resourcesExtension = ".resources";
if (requestedAssemblyName.EndsWith(resourcesExtension, StringComparison.Ordinal))
{
requestedAssemblyName = requestedAssemblyName.Remove(requestedAssemblyName.Length - resourcesExtension.Length);
}
var resourceName = "WpfAppTest1.Resources." + requestedAssemblyName + ".dll";
var appAssembly = typeof(App).Assembly;
using (var stream = appAssembly.GetManifestResourceStream(resourceName))
{
// Check the resource was found
if (stream == null)
return null;
var assemblyData = new byte[stream.Length];
stream.Read(assemblyData, 0, assemblyData.Length);
var loadedAssembly = Assembly.Load(assemblyData);
return loadedAssembly;
}
}
The key point to note is the removal of the .resources extension which sometimes comes through when resolving assemblies
This is enough to get the assembly loading from the resources, however there will be no implicit styling applied to the charting controls (I am assuming this is to do with how WPF discovers its themes at runtime).
To work around this problem, I put the following in App.xaml:
<Application.Resources>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="pack://application:,,,/system.windows.controls.datavisualization.toolkit;component/Themes/generic.xaml" />
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</Application.Resources>
This merges the default chart styles which should then get implicitly applied.
To test it, I used the following content in MainWindow.xaml:
<chartingToolkit:Chart Title="Some Chart" Background="Blue">
<chartingToolkit:Chart.Series>
<chartingToolkit:ScatterSeries Title="Series 1" />
</chartingToolkit:Chart.Series>
</chartingToolkit:Chart>