{"id":1530,"date":"2014-10-30T18:32:47","date_gmt":"2014-10-30T22:32:47","guid":{"rendered":"http:\/\/www.ikriv.com\/blog\/?p=1530"},"modified":"2014-10-30T18:32:47","modified_gmt":"2014-10-30T22:32:47","slug":"one-more-time-about-resource-vs-embeddedresource","status":"publish","type":"post","link":"https:\/\/ikriv.com\/blog\/?p=1530","title":{"rendered":"One more time about Resource vs. EmbeddedResource"},"content":{"rendered":"

In Visual Studio you can set “Build Action” for a project item to ‘Resource’ or ‘Embedded Resource’, among other things. The difference between the two is confusing, and exact up-to-date documentation is hard to find. (This StackOverflow post<\/a> is probably the best, but not 100% accurate.) Today I became confused one more time, so I decided to clear up the matter and put an end to the confusion.
\n
\nFirst of all, both<\/b> kinds of resource are actually embedded in the executable. ‘EmbeddedResource’ files are placed directly into the executable as manifest resources. All ‘Resource’ files are put in a special structured manifest resource named ‘ProjectName<\/i>.g.Resources<\/code>‘.<\/p>\n

Embedded Resources<\/b><\/p>\n

Embedded resources are the same as manifest resources. You can see them as .mresource<\/code> records in ILDASM. If in a project named MyProject<\/code> you create a file named Texts\\Guide.txt<\/code> and mark it as EmbeddedResource, the project output will have a manifest resource named MyProject.Texts.Guide.txt<\/code>.<\/p>\n

Embedded resources can be enumerated by calling Assembly.GetManifestResourceNames()<\/code> and read via Assembly.GetManifestResourceStream()<\/code>.<\/p>\n

Resx files<\/b><\/p>\n

Embedded resource has no predefined structure: it is just a named blob of bytes. So called “.resx” file is a special kind of embedded resource. It is a string-to-object dictionary that maps a name to an object. The object may be a string, an image, an icon, or a blob of bytes. Resx files can be used for localization: in addition to the name each object may have a culture<\/i>, e.g. “Neutral”, or “English (UK)”.<\/p>\n

You can add resx file to your project by right clicking on the project name, choosing Add->New Item...<\/code> and then selecting Visual C# Items->General->Resource file<\/code>. The entire resx file is placed into the executable as a single manifest resource. In the name of the manifest resource “.resx<\/code>” extension is replaced with “.resources<\/code>“.<\/p>\n

Resx files are accessed via the System.Resources.ResourceManager<\/code> class. Note that the “base name” supplied to the constructor is the file name without<\/b> extension. You can retrieve a particular resource by calling ResourceManager.GetString()<\/code>, ResourceManager.GetObject()<\/code>, or ResourceManager.GetStream()<\/code>. You can get an entire dictionary for a particular culture via ResourceManager.GetResourceSet()<\/code>.<\/p>\n

Resource Build Action<\/b><\/p>\n

Files marked with build action of “Resource” are added to a special resx file called ProjectName<\/i>.g.resx<\/code>. This file is generated during the build, it is not part of the project. You can access content of the ‘Resource’ files by creating an instance of ResourceManager<\/code> and calling GetStream(filename<\/i>)<\/code>. Additionally, in WPF applications you can access these resources via Application.GetResourceStream()<\/code> in C# and via things like <Image Source=\"filepath<\/i>\" \/><\/code> in XAML.<\/p>\n

Project resources<\/b><\/p>\n

When you edit project resources on the Resources tab of the project property pages, Visual Studio creates another special resx file named Properties\\Resources.resx<\/code>. Corresponding manifest resource name is ProjectName<\/i>.Properties.Resources.resources<\/code> (yes, “resources” is repeated twice, one comes from the file name, and the other from the “.resx” extension being replaced with “.resources”). Visual Studio also creates a file called Resources.Designer.cs<\/code> that contains code for easy access to the dictionary items. E.g. a string named “WindowHeader” may be accessed simply as Properties.Resource.WindowHeader<\/code>, which will call ResourceManager<\/code> behind the scenes.<\/p>\n

Putting it all together<\/b><\/p>\n

A sample program (ResourceTypes.zip<\/a>) demonstrates different kinds of resources and how to access them.<\/p>\n

It has<\/p>\n