We also discussed resources in our article, How to Read a String From a .resx (Resource) File in C#<\/a>, where we explored how developers can extract strings from RESX files, a type of resource.<\/p>\n However, in this article, we’ll focus on embedded resources.<\/strong><\/p>\n Let’s dive in.<\/p>\n In addition to data in our program, we often need outside resources<\/strong>. Sometimes, these resources are provided by the end-user, but there are also situations where we have all the resources at the time of development. We need an option to ship them with our program somehow.<\/strong><\/p>\n Rather than merely attaching files to our program, it’s advantageous to include them within its assembly<\/strong>. This ensures they’re always readily available and eliminates the risk of overlooking them.<\/p>\n The encapsulation of resources within the program itself constitutes embedded resources.<\/strong><\/p>\n We’ll walk through the creation of a sample command-line application in several steps:<\/p>\n Let’s start by preparing a quick test program, a basic command-line app. We can either make a new command line app right from Visual Studio or utilize the dotnet command:<\/p>\n Once our command-line project is set up, we can promptly incorporate embedded resources into our app.<\/strong><\/p>\n We’ll generate sample text ( Let’s set up the folders and files for our resources<\/strong>. First, we’ll create two subfolders within our project directory: Here’s how we can do it:<\/p>\n So, we have created a folder structure where the Next, copy some text files from the disk into the After completing these steps, our folder structure will look like this:<\/p>\n The actual content of the files is not significant for our purposes.<\/p>\n Now that we’ve included all the folders and files in our .NET\/C# project, they should be visible in the Solution Explorer.<\/strong><\/p>\n To designate these files as embedded resources<\/strong>, follow these steps:<\/p>\n Now that we’ve embedded three resources in our application, let’s write some C# code to retrieve a list of these files<\/strong>.<\/p>\n First, we’ll need a handle to the assembly containing the embedded resources<\/strong>. Since we’ve added all resources to our main assembly, we can easily reference it:<\/p>\n Once we have the assembly handle, we can list all the resources within it using the This is a general function, so we first check if we have a valid assembly handle. Then, we call the By running the current code, we will get the list of files:<\/p>\n Dots separate each resource name.<\/strong> If we take the example of the PDF file, ‘ ‘ This structure allows us to have two identical files named In the .csproj file, Visual Studio records the embedded file selection. Here’s the relevant portion of the XML:<\/p>\n This XML fragment indicates which files are designated as embedded resources.<\/strong><\/p>\n By modifying the .csproj file<\/strong>, we can embed files that aren’t within our project’s subfolders<\/strong>, a capability not directly available in Visual Studio. Editing the file allows us to include files from different locations, like so:<\/p>\n With this setup, we’re embedding our solution file, one folder up, and even a Notice how all such resources are named as if they were in the same folder as our assembly.<\/strong><\/p>\n However, this was just a test to explore the possibility. While feasible, embedding resources from outside our project is ill-advised. We should not embed resources outside our project, as we can\u2019t guarantee their availability at build time.<\/strong><\/p>\n Now that we’ve learned how to retrieve a list of embedded resources in our main assembly let’s attempt to list the embedded resources in a satellite assembly that we’ll create.<\/p>\n For this experiment, let’s create a new project and embed a text file into that assembly:<\/p>\n Next, open this new project in Visual Studio and embed a text file<\/strong>. Alternatively, we can edit the .csproj file:<\/p>\n This setup will embed the We can apply the same approach to any assembly<\/strong>, including satellite assemblies.<\/p>\n We already have the method Then, we can call the method:<\/p>\n Since our satellite assembly contains only one embedded resource, we’ll receive a list with just one element:<\/p>\n This demonstrates how we can read embedded resources from any assembly<\/strong>, providing flexibility in resource management.<\/p>\n To list all the embedded resources in all the assemblies comprising our solution, we can first obtain a list of all assemblies of the current application domain<\/strong>:<\/p>\n Then, we can iterate over this list<\/strong> and call the This approach allows us to comprehensively gather information about embedded resources across all assemblies within our solution.<\/p>\n Indeed, understanding how to access the content of an embedded resource is crucial for utilizing them.<\/p>\n Similar to retrieving a list of all embedded resources using the Once we have a To streamline the process of locating a specific embedded resource across all assemblies within our solution, we can implement a utility method:<\/p>\n Method iterates through each assembly and retrieves the list of embedded resources within that assembly using If the This utility method simplifies locating and accessing specific embedded resources within our solution’s assemblies.<\/strong><\/p>\n To find an embedded resource by its complete name, we can create a finder method that returns the name if it matches precisely:<\/strong><\/p>\n This method utilizes the Similarly, to find a resource by specifying only part of its name, such as ‘pdf-file.pdf’, we can modify the finder method to check for name containment:<\/strong><\/p>\n Here, we use the Once we have a Method utilizes a To display the embedded PDF file, we first need to save its content to disk, then open the saved file using a PDF application<\/strong>. We can accomplish this with two methods:<\/p>\n The The In conclusion, embedding resources into .NET assemblies is straightforward. We can select them in Visual Studio or manually add them as XML tags in the .csproj file.<\/p>\n Every embedded resource is named by concatenating the assembly name with the folder path and file name, separated by commas. For example, ‘Embedded_Resources_in_NET.Resources.Pdf.pdf-file.pdf’.<\/p>\n Invoking the GetManifestResourceNames () method of the Assembly object retrieves the list of all embedded resources in an assembly. Similarly, the GetManifestResourceStream() method obtains the embedded resource stream.<\/p>\n This simple yet powerful mechanism allows us to seamlessly integrate various resources, such as text files, images, and even binary files like PDFs, directly into our .NET assemblies, streamlining deployment and ensuring that all necessary resources are readily available to our applications.<\/p>\n","protected":false},"excerpt":{"rendered":" We’ve covered resources in a couple of our previous articles. In Localization in ASP.NET Core, we delved into .NET localization, touching upon resources since XML files utilized for localization fall under .NET resources. We also discussed resources in our article, How to Read a String From a .resx (Resource) File in C#, where we explored […]<\/p>\n","protected":false},"author":53,"featured_media":62189,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_et_pb_use_builder":"","_et_pb_old_content":"","_et_gb_content_width":"","footnotes":""},"categories":[12],"tags":[2202,2201,2203,1212,2200],"class_list":["post-116937","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-csharp","tag-assembly","tag-embedded-resources","tag-embedding","tag-files","tag-resources","et-has-post-format-content","et_post_format-et-post-format-standard"],"yoast_head":"\nWhat Are Embedded Resources?<\/h2>\n
Test Project With Embedded Resources<\/h2>\n
\n
dotnet new console -n Embedded_Resources_in_NET<\/code><\/p>\n.txt<\/code>) and PDF (.pdf<\/code>) files for testing. We can grab files from our hard drive or extract them from the Code Maze sample application.<\/p>\nCreating Sample Folders and Files<\/h3>\n
Resources<\/code> and Files<\/code>. While the specific names aren’t crucial, Resources<\/code> is commonly used.<\/strong><\/p>\nmd Resources\r\ncd Resources\r\nmd Pdf\r\ncd ..\r\nmd Files<\/pre>\n
Resources<\/code> and Files<\/code> folders are on the same level, and the Pdf<\/code> folder is under Resources<\/code>.<\/p>\nResources<\/code> and Files<\/code> folders, naming it text-file.txt<\/code>. Similarly, let’s duplicate a sample PDF file, naming it pdf-file.pdf<\/code>, and place it within the Pdf<\/code> subfolder under Resources<\/code>.<\/p>\n|\r\n|-- Resources\r\n |-- text-file.txt\r\n |-- Pdf\r\n |-- pdf-file.pdf\r\n|-- Files\r\n |-- text-file.txt\r\n<\/pre>\n
Adding Embedded Resources Using Visual Studio<\/h3>\n
\n
![\"embedded](\"https:\/\/code-maze.com\/wp-content\/uploads\/2024\/05\/EmbeddedResource.png\")
<\/a><\/p>\nReading the List of Embedded Resources in Our Application<\/h2>\n
private static Assembly ThisAssembly\r\n => typeof(SampleResourceReader).Assembly;<\/pre>\n
GetManifestResourceNames()<\/code> method:<\/p>\nprivate static void ListResourcesInAssembly(Assembly? assembly)\r\n{\r\n if (assembly is null) \r\n return;\r\n\r\n var resources = assembly.GetManifestResourceNames();\r\n if (resources.Length == 0)\r\n return;\r\n\r\n Console.WriteLine($\"Resources in {assembly.FullName}\");\r\n foreach (var resource in resources)\r\n {\r\n Console.WriteLine(resource);\r\n }\r\n\r\n Console.WriteLine();\r\n}<\/pre>\nGetManifestResourceNames()<\/code> method to get the list of all the embedded resources within it. If there are no embedded files, we exit the function. Otherwise, we display the names of the resources in the Console.<\/strong><\/p>\nThe Names of the Embedded Files<\/h3>\n
Resources in Embedded_Resources_in_NET, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null\r\nEmbedded_Resources_in_NET.Files.text-file.txt\r\nEmbedded_Resources_in_NET.Resources.text-file.txt\r\nEmbedded_Resources_in_NET.Resources.Pdf.pdf-file.pdf<\/pre>\n
Embedded_Resources_in_NET.Resources.Pdf.pdf-file.pdf<\/code>‘, and split it by dots (except the last one), we get:<\/p>\nEmbedded_Resources_in_NET\r\nResources\r\nPdf\r\npdf-file.pdf<\/pre>\n
Embedded_Resources_in_NET<\/code>‘ is our assembly name<\/strong>, Resources<\/code> and Pdf<\/code> are the respective sub-folders<\/strong>, and pdf-file.pdf<\/code> is the filename of the embedded resource<\/strong>. The dot (‘.’) is a separator between the assembly name, the entire folder structure, and the name of the embedded resource itself.<\/p>\ntext-file.txt<\/code> as embedded resources in our assembly without conflict<\/strong>. One resides in the Files<\/code> sub-folder, hence its name is Embedded_Resources_in_NET.Files.text-file.txt<\/code>, while the other is in the Resources<\/code> sub-folder, making its name Embedded_Resources_in_NET.Resources.text-file.txt<\/code>. Since the names are distinct, there’s no issue.<\/strong><\/p>\nEmbedded Resources in the .csproj File<\/h3>\n
<ItemGroup>\r\n <EmbeddedResource Include=\"Files\\text-file.txt\" \/>\r\n <EmbeddedResource Include=\"Resources\\Pdf\\pdf-file.pdf\" \/>\r\n <EmbeddedResource Include=\"Resources\\text-file.txt\" \/>\r\n<\/ItemGroup><\/pre>\n
Embedded Resources Outside Our Project<\/h3>\n
<ItemGroup>\r\n <EmbeddedResource Include=\"Files\\text-file.txt\" \/>\r\n <EmbeddedResource Include=\"Resources\\Pdf\\pdf-file.pdf\" \/>\r\n <EmbeddedResource Include=\"Resources\\text-file.txt\" \/>\r\n <EmbeddedResource Include=\"..\\Embedded_Resources_in_NET.sln\" \/>\r\n <EmbeddedResource Include=\"..\\..\\README.md\" \/>\r\n<\/ItemGroup><\/pre>\n
README.md<\/code> file that is two folders up. Executing this code will yield:<\/p>\nResources in Embedded_Resources_in_NET, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null\r\nEmbedded_Resources_in_NET.Files.text-file.txt\r\nEmbedded_Resources_in_NET.Resources.text-file.txt\r\nEmbedded_Resources_in_NET.Resources.Pdf.pdf-file.pdf\r\nEmbedded_Resources_in_NET.Embedded_Resources_in_NET.sln\r\nEmbedded_Resources_in_NET.README.md<\/pre>\n
Embedded Resources in a Satellite Assembly<\/h2>\n
dotnet new classlib -o Embedded_Resources_in_NET_Satellite<\/code><\/p>\n<ItemGroup>\r\n <EmbeddedResource Include=\"Resources\\text-file.txt\" \/>\r\n<\/ItemGroup><\/pre>\n
text-file.txt<\/code> into our satellite assembly.<\/strong><\/p>\nReading a List of Embedded Resources in a Satellite Assembly<\/h3>\n
ListResourcesInAssembly()<\/code> for this purpose. All we need to do is specify the correct assembly:<\/p>\nprivate static Assembly SatelliteAssembly =>\r\n Assembly.Load(\"Embedded_Resources_in_NET_Satellite\");<\/pre>\n
public static void ListResourcesInOurSatelliteAssembly()\r\n => ListResourcesInAssembly(SatelliteAssembly);<\/pre>\n
Resources in Embedded_Resources_in_NET_Satellite, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null\r\nEmbedded_Resources_in_NET_Satellite.Resources.text-file.txt<\/pre>\n
Reading a List of Embedded Resources in All of the Assemblies of Our Project<\/h3>\n
private static Assembly[] AllAssembliesOfCurrentAppDomain\r\n => AppDomain.CurrentDomain.GetAssemblies();<\/pre>\n
ListResourcesInAssembly<\/code> method for each assembly:<\/p>\npublic static void ListResourcesInAllAssemblies() \r\n => AllAssembliesOfCurrentAppDomain.ToList().ForEach(ListResourcesInAssembly);<\/pre>\n
Reading the Content of an Embedded Resource<\/h2>\n
GetManifestResourceNames()<\/code> method, we can obtain the content of a resource via the GetManifestResourceStream()<\/code> method.<\/strong><\/p>\nStreams<\/code> extensively on Code Maze, with articles such as StreamWriter and StreamReader Classes in C#<\/a>, How to Use MemoryStream in C#<\/a>, Using Streams with HttpClient to Improve Performance and Memory Usage<\/a>, and more.<\/div>\nStream<\/code> object, we can perform various operations, including reading, transforming, displaying, saving to disk, transmitting over the network, and more.<\/strong> Streams<\/code> provide a flexible and powerful means of handling data in C#.<\/p>\nFinding an Embedded Resource in Assemblies<\/h3>\n
private static Stream? FindResource(Func<string[]?, string?> finder)\r\n{\r\n foreach (var assembly in AllAssembliesOfCurrentAppDomain)\r\n {\r\n var resourceNames = assembly.GetManifestResourceNames();\r\n var resourceName = finder(resourceNames);\r\n\r\n if (resourceName is not null)\r\n {\r\n Console.WriteLine($\"Resource {resourceName} found in {assembly.FullName}\");\r\n return assembly.GetManifestResourceStream(resourceName);\r\n }\r\n }\r\n\r\n return null;\r\n}<\/pre>\nGetManifestResourceNames()<\/code>, and then passes this list to an external finder<\/code> method.<\/p>\nfinder<\/code> method successfully locates the desired resource, we print a message indicating its discovery and return the corresponding Stream<\/code> using GetManifestResourceStream()<\/code>. If the resource is not found in any assembly, we return null.<\/p>\nFinding a Resource by Specifying the Whole Name<\/h3>\n
FindResource(names => names?.FirstOrDefault(rn => rn == resourceName));<\/code><\/p>\nFirstOrDefault)=<\/code> LINQ function to find the first resource name that matches the provided resourceName<\/code>.<\/p>\nFinding a Resource by Specifying Part of a Name<\/h3>\n
FindResource(names => names?.FirstOrDefault(rn => rn.Contains(partialResourceName)));<\/code><\/p>\nContains<\/code> method to check if any resource name contains the specified partialResourceName<\/code>. If a match is found, that resource name is returned.<\/p>\nDisplaying the Content of an Embedded Resource<\/h2>\n
Stream<\/code> object representing our embedded resource, displaying its content on the screen is straightforward<\/strong>:<\/p>\nprivate static void DisplayResource(string resourceName, Stream resourceStream)\r\n{\r\n using var reader = new StreamReader(resourceStream);\r\n var resourceContent = reader.ReadToEnd();\r\n Console.WriteLine($\"Resource {resourceName} content:\");\r\n Console.WriteLine(resourceContent);\r\n}<\/pre>\nStreamReader<\/code> to read the content of the resource stream. It then prints the resource name and its content to the console.<\/p>\nShowing the PDF File<\/h3>\n
private static string SaveResourceToAFile(string partialResourceName, Stream resourceStream)\r\n{\r\n var tempFileName = Path.Combine(Path.GetTempPath(), partialResourceName);\r\n using var fileStream = new FileStream(tempFileName, FileMode.Create, FileAccess.Write);\r\n resourceStream.CopyTo(fileStream);\r\n fileStream.Close();\r\n\r\n return tempFileName;\r\n}\r\n\r\nprivate\u00a0static\u00a0void\u00a0ShowFile(string\u00a0fileName)\u00a0\r\n => Process.Start(new ProcessStartInfo(fileName) { UseShellExecute = true });<\/pre>\nSaveResourceToAFile()<\/code> method accepts the partial file name and the Stream representing the embedded resource. It creates a temporary file in the system’s temporary folder and writes the contents of the resource stream to that file. It then returns the name of the newly created file.<\/p>\nShowFile()<\/code> method starts a new process using the system’s default application for opening PDF files, passing the file name as an argument. This opens the PDF file using the default PDF viewer installed on the system.<\/p>\nConclusion<\/h2>\n