Is there a way to use a resource dictionary in multiple applications? What I have is a theme generator which uses merged dictionaries etc... works GREAT! I'm looking for a way to reference this project for the resource dictionaries into all my applications. (thus, having my theme engine in every File>New I decide to create) So far my research has led me to nothing.
Ok so I've found out that I can use the pack URI syntax to grab the resource dictionaries from application A and use them in application B
First I made a classlibrary and removed the default class1.cs
Then I added a new item (there was no option for a .xaml file so I added a .xml file and changed the extension)
Then moved the resource dictionary code into that file.
Referenced the new .dll as you would any other and now I can access the resource dictionary file using the below syntax.
<ResourceDictionary Source = "pack://application:,,,/App_A;Component/App_A_ResourceDictionary.xaml"/>
When swapping the files its the same syntax only omit the "pack://application,,," part.
Although this wasn't everything I wanted (so far) it has been the best solution I've found.
The part now that I want is the ability to house the swapping logic within the .dll. If I can do that... then my theme library can be PnP to any app with minimum fuss.
Related
I need to extract some resources from the MyForm.resx file in runtime. In particular, I need to access captions of controls, which are stored inside.
From what I know, resources are embedded into assembly during compilation. Knowing specific form I want access to (let it be MyForm) and specific name of the resource (like lbSth.Text), is there a way to access those resources in runtime?
There are two ways, depending on what is actually needed.
One may use System.Resources.ResourceManager class. Construct it by passing a Type of form or control, which resources you want to access. It automatically resolves satellite assemblies and provides access to resources related to a form. The downside is that it doesn't allow iterating through key/value pairs, only accessing a resource of known key, so you have to know them in advance (for instance, process resx files beforehand)
It turns out, that resources in binary form are kept as embedded resources in the assembly. However, translations are being kept in satellite assemblies. To access those, use eg. Assembly.GetExecutingAssembly().GetSatelliteAssembly(), however keep in mind, that resources in there will have different names. For instance, MyForm.resources in satellite assembly will be named, eg. MyForm.en.resources.
Afterwards, use resolvedAssembly.GetManifestResourceStream() to access embedded resource and then finally System.Resources.ResourceReader class to iterate through resources in that file.
I'm putting together a simple help system for my WPF app using XAML FlowDcouments (just .xaml files, no code-behind). I've simply added them to my project with Build Action = Resource, and I can load and display them as required.
Now, I'm trying to make it a bit more flexible, in that after the installation of the app, I want the user to be able to download additional (or newer versions of the existing) FlowDocument XAML help files. Given this, I'm now wondering where the best place to store these files is. A few questions/ideas:
Can I leave them as resource files, and overwrite or add new files as required? I can't find a example of how to add/edit resources at runtime on SO/Google. Is it even possible?
If not, is there a recommended location to store these files? They should be available to all users, so they can't go into the User's directory - they would have to go in the program directory. Does the program directory have write-access (I remember having issues with that before)?
Any other ideas?
Thanks.
The resource files are embedded into the executable and therefore you cannot change them.
As for a common place to put your downloaded help files, you cannot store them in "Program Files" since you would need admin privileges to write there.
I suggest you put them into SpecialFolder.CommonApplicationData (see http://msdn.microsoft.com/en-us/library/system.environment.specialfolder(v=vs.80).aspx), which is defined as "The directory that serves as a common repository for application-specific data that is used by all users."
My prism based silveright application is divided into multiple xaps to reduce initial download size and support multi tenant application.
However, I cannot access the resource dictionaries defined in external assembly (i.e. the resource .xaml file is part of an assembly that complies/ is copied into a different xap)
Any suggestions ? because the standard syntax for accessing external resources files does not work
The book Pro Silverlight 2 in VB 2008 (p166) [MacDonald] says "Unfortunately, Silverlight doesn't currently allow you to merge resource dictionaries, which means there is no way to split your application resources into separate files and then merge them into your application (which is possible in WPF)." I don't know if things have changed since then, but I would suggest that is the reason.
Within a Silverlight library, I need to validate incoming XML against a schema. The schema is composed of 5 interdependent .xsd files; the main file uses "xs:import" to reference all of the others, and there are other references among them.
Assuming that the .xsd files need to be distributed with the library (i.e. not hosted on some well-known external URL), how should I structure my project to include them?
I have found that I can embed them in the library project with build type "Resource" and then load them (individually) using Application.GetResourceStream() and a relative URI with the ";content" flag in it. But if I take this approach, can I validate against the interdependent set of 5 files? What happens when the schema parser tries to resolve the interdependencies?
Or should I embed them with build type "Content" and access the main one with some other sort of URL?
Or???
To summarize: how should I use these 5 .xsd files in my project so that I will be able to validate XML against them?
EDIT: It's not clear whether it's even possible to validate in Silverlight. I spun off a related question.
I cannot say much about Silverlight limitations with respect to validation, but the question itself is more generic - one might want to store .xsd files as resources in a desktop .NET application, for example - so I will answer that part.
You can have full control over resolution of URIs in xs:import by means of XmlSchemaSet.XmlResolver property. Just create your own subclass of XmlResolver, override GetEntity() method, and implement it using GetResourceStream(), or GetManifestResourceStream(), or whichever other way you prefer.
I've moved all image resources in a large multi-project solution to a new project specifically created for shared resources.
Adding a new reference to other projects where the shared images are used is working as expected. The image in the selected button below continues to appear in designer but with issues.
In VS Designer, I'm unable to select shared resources in the Image Editor, having instead to manually edit the designer code.
More specifically, in the Image Editor dialog (accessed from the 'Image' property of an existing control) I select 'Select from File/Resource..." to pop up the Select Resource dialog (shown). There, where I used to access all local project resources (Resources.resx), I would like now to add access to the new shared resources project. Ideally, I would add a second item to the dropdown shown which switches to the resx for the shared resources project.
How can this be done? Is there a better way?
I was able to share a resx file between project and using it in the designer in VS 2008 SP1 (I don't know other versions). Differently from other approaches, here resources are statically and dynamically shared, so at runtime there's really one copy of the shared resources. No storage or memory waste and it's easy to maintain with tons of projects.
Follow the guide and tell me if it works for you:
Create a class project Resources;
Create a resource file (go to Properties -> Resources of the project);
Move the resource file (default Resources.resx) to the root of the project;
Rename the resources file Resources.resx -> GlobalResources.resx;
Modify the resources file modifier to Public (double click on the resources file, "Access Modifier" -> "Public");
Copy any resource file to the root directory of the project;
Add any resource to the resource file using "Add Existing File" and selecting resources on the root directory of the project.
The project in the Solution Explorer should look like this:
Now in any project you need the resx file to be shared do this:
Add the "Resource" project as a dipendency;
Edit manually the project file (*.csproj) and add the following lines in the resources file ItemGroup (create a local resource file if you want to see it):
<ItemGroup>
...
<EmbeddedResource Include="..\Resources\GlobalResources.resx">
<Link>GlobalResources.resx</Link>
<Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>GlobalResources.Designer.cs</LastGenOutput>
<CustomToolNamespace>Resources</CustomToolNamespace>
</EmbeddedResource>
...
</ItemGroup>
Obviously, the "Include" attribute should be the correct relative path to GlobalResources.resx.
Use the resources in the designer as you was asking.
In my project, the following lines are generated and added to the project automatically when I do this:
<Compile Include="..\Resources\GlobalResources.Designer.cs">
<Link>GlobalResources.Designer.cs</Link>
<AutoGen>True</AutoGen>
<DesignTime>True</DesignTime>
<DependentUpon>GlobalResources.resx</DependentUpon>
</Compile>
If they aren't added, add them manually.
Now the project should look like this in the Solution Explorer (likend files should be marked differently):
Last two steps:
Click on the linked "GlobalResources.resx" and on the Properties set "None" as the "BuildAction". "Custom Tool Namespace" should already be set to "Resources";
Click on the linked "GlobalResources.Designer.resx" and on the Properties set "None" as the "BuildAction".
And you are done: at this point you should really be able to use the resources you added in the shared resx in the designer selecting "GlobalResources.resx" in the "Project Resource file" dialog of your question. And as told it's really shared even at runtime! In the Properties panel you should see the full Namespace and class of the external project. If you remove the dependency on the "Resource" project it doesn't even compile. If it doesn't work for you, insist until it works and in case tell me where the guide is wrong. It have to work! Let me know.
I came accross the same problem recently. Looked around MS documentation but couldn't find any good solutions. I was eventually able to get the image editor in the WinForms designer to recognize resource files from other projects using the method described below. It is hacky - if anyone has a cleaner solution they want to share please post. I have tested this on VS 2008 only.
Before I start I should say that if you just want to make the items in a Resources.resx file accessible to other projects, you can just edit its properties and set the access modifier for the generated class to public so it uses PublicResXFileCodeGenerator. The gymnastics below are only needed if you want to get the WinForms designers to pick up images inside this resource file as described in the post above from Douglas.
Say that your solution has the following layout. The default namespace for the various projects (right click on a project node in solution explorer -> Properties -> Application tab) is important here, so I've put this in brackets after the project names.
MySolution
SharedProject (default namespace = SharedProject)
SharedProject.csproj
WinFormsProject1 (default namespace = WinFormsProject1)
WinFormsProject1.csproj
WinFormsProject2 (default namespace = WinFormsProject2)
WinFormsProject2.csproj
You want to create a resource file in SharedProject containing images that can be used by WinFormsProject1 and WinFormsProject2.
First create a new Resource file in the root of SharedProject, let's call it SharedResources.resx. It is important that this file uses ResXFileCodeGenerator rather than PublicResXFileCodeGenerator for reasons which will become clear later.
Edit SharedResources.resx in Visual Studio and add the image resources you want to share. Visual Studio should also generate a class file for you inside SharedProject called SharedResources.designer.cs.
Your solution should now look like this:
MySolution
SharedProject (default namespace = SharedProject)
SharedProject.csproj
SharedResources.resx
SharedResources.Designer.cs
WinFormsProject1 (default namespace = WinFormsProject1)
WinFormsProject1.csproj
WinFormsProject2 (default namespace = WinFormsProject2)
WinFormsProject2.csproj
If you open up SharedProject.csproj with a text editor you should see the following entries:
<EmbeddedResource Include="SharedResources.resx">
<Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>SharedResources.Designer.cs</LastGenOutput>
</EmbeddedResource>
<Compile Include="SharedResources.Designer.cs">
<AutoGen>True</AutoGen>
<DesignTime>True</DesignTime>
<DependentUpon>SharedResources.resx</DependentUpon>
</Compile>
Now you need to make the resources accessible inside WinFormsProject1. To do this you'll need edit WinFormsProject1.csproj in a text editor because some of the properties you need to set are not exposed inside Visual Studio.
Open up the WinFormsProject1.csproj file and add the following inside an ItemGroup:
<Compile Include="..\SharedProject\SharedResources.Designer.cs">
<Link>SharedResources.Designer.cs</Link>
<AutoGen>True</AutoGen>
<DesignTime>True</DesignTime>
<DependentUpon>SharedResources.resx</DependentUpon>
</Compile>
<EmbeddedResource Include="..\SharedProject\SharedResources.resx">
<Link>SharedResources.resx</Link>
<Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>SharedResources.Designer.cs</LastGenOutput>
<CustomToolNamespace>SharedProject</CustomToolNamespace>
<LogicalName>SharedProject.SharedResources.resources</LogicalName>
</EmbeddedResource>
The key things here are CustomToolNamespace and LogicalName. By default Visual Studio uses the project's default namespace to name resources and to generate the *.Designer.cs file. Since SharedProject and WinFormsProject1 have different default namespaces the default behaviour causes the resource that is embedded in WinFormsProject1 to be incompatible with the *.Designer.cs file that is inside SharedProject. This can be prevented by overriding CustomToolNamespace and LogicalName.
Now do the same for WinFormsProject2.csproj. Go back to Visual Studio. It will notice that you've changed the csproj files and ask to reload the projects - choose "reload". You should find that you can now choose images from SharedResources.resx when designing forms in both WinFormsProject1 and WinFormsProject2.
Essentially what all of this does is make VS include the SharedResources.resx file from SharedProject in the WinFormsProject1 and WinFormsProject2 projects. There is only one .resx source file (in SharedProject), but when you compile the solution there will actually be three identical classes called SharedProject.SharedResources, one in each of the three assemblies, but since all have internal visibility they won't interfere with one another even if you add a reference between the projects.
SHARING RESOURCES BETWEEN PROJECTS IN VS2012
in 3 easy steps using the designer only!
create a project and add your resources to be shared as usual
create another project and 'add as link' the resources.resx of the first project in the 'add existing item' Dialog, accessible from the context menu
select images from the linked resource file as desired; this can be selected in the 'project resource file' pull down menu within the 'select resource' Dialog, accessible from the properties pane
VOILA!
For Visual Studio 2015+
There is an easy, straightforward way, that is not supported in the VisualStudio UI. So if you are not afraid of editing the project files, read on.
If you have not already done so, add a new shared project into the solution.
If you have not already done so, include the new shared project as a shared project reference to your peripheral project.
Note how this shared project is included in the peripheral project (.csproj file) in a straight forward manner:
<Import Project="..\Common\Common.projitems" Label="Shared" />
Thus, even though the VS UI does not expose it, everything in the shared project (.projitems file) is included directly into the peripheral project. Adding the following resource definitions to the shared project (.projitems file) will include them directly into your peripheral project. But, because the Resource element is not supported by the VS UI for shared projects, these files will be hidden and ignored in the IDE.
<ItemGroup>
<Resource Include="$(MSBuildThisFileDirectory)Resources\one 16x16.png" />
<Resource Include="$(MSBuildThisFileDirectory)Resources\one 64x64.png" />
<Resource Include="$(MSBuildThisFileDirectory)Resources\one.ico" />
<Resource Include="$(MSBuildThisFileDirectory)Resources\two 16x16.png" />
<Resource Include="$(MSBuildThisFileDirectory)Resources\three 16x16.png" />
<Resource Include="$(MSBuildThisFileDirectory)Resources\four 16x16.png" />
<Resource Include="$(MSBuildThisFileDirectory)Resources\five 16x16.png" />
<Resource Include="$(MSBuildThisFileDirectory)Resources\six 16x16.png" />
</ItemGroup>
Lastly, whereas your peripheral project resources might have relative paths (e.g. ".\Resources\main.ico"), these resources are compiled into your peripheral project with base ids, not absolute or relative. e.g.:
<Window x:Class="Common.Shared"
...
Icon="one.ico">
<Window.Resources>
<ResourceDictionary>
<BitmapImage x:Key="one64" UriSource="one 64x64.png"/>
</ResourceDictionary>
</Window.Resources>
You only need add a new class project with a RESX file where you include the resources (images, texts, etc). After in the other projects add a reference to this and use the Resource class name in order to access the resource needed, for example: Project.SharedImages.Upload_64x64 (the result is a Bitmap ready to use in this case)
Charlie's answer works great!
Just a small change: If you want to skip the last two steps, use this version of the included items when you modify a project file.
<None Include="..\Resources\GlobalResources.resx">
<Link>GlobalResources.resx</Link>
<Generator>PublicResXFileCodeGenerator</Generator>
<LastGenOutput>GlobalResources.Designer.cs</LastGenOutput>
<CustomToolNamespace>Resources</CustomToolNamespace>
</None>
<None Include="..\Resources\GlobalResources.Designer.cs">
<Link>GlobalResources.Designer.cs</Link>
<DependentUpon>GlobalResources.resx</DependentUpon>
</None>