Prerequisites

For this example you'll need to import the System.Reflection namespace, as this namespace contains the Assembly class that is used to retrieve the image at run-time.

Creating the PocketPC Application

Start by creating a new Smart Device Application from the New Project dialog. You can choose between a C# or a Visual Basic .NET application as this example will show the code for both languages. Choose Pocket PC as the platform you want to target and choose Windows Application as the type of project:

Figure 1 - The Smart Device Application Wizard

When the Smart Device Application Wizard has finished, drag a Picturebox from the toolbox on the form, and resize it so it will fit the contents of the image you want to display:

Figure 2 - A Smart Device Application Form with a Picturebox

Embedding the Image

With the form done, you'll now need to add an image to the project. This image will be embedded in the assembly and displayed on the Picturebox you just added. To do this, right-click your project in the Solution Explorer, choose Add | Add Existing Item and then browse for the image you want to display on your Pocket PC form. The image will be copied to the project folder and added to the project. Select the image in the Solution Explorer and then open the Properties Window by pressing F4 if you didn't have it open yet. Set the Build Action under the Advanced category to Embedded Resource as shown in the following figure:

Figure 3 - The Properties grid for the Embedded Image

Now when you compile your application, the image will be embedded in the assembly, which is the project's executable in this example.

Retrieving the Image

The next step is to write some code that will read the image from the assembly at
run-time and display it on the Picturebox.

In both VB.NET and C#, you'll need to import the System.Reflection namespace to save you from typing the full path to the Assembly class every time you need it. At the top of your page, below the other using or Imports statements you may have, but before your Class definition, add this line for C#:

and this for Visual Basic .NET:


Next, double-click somewhere on an empty spot of the Form (make sure you don't accidentally hit the Picturebox). Visual Studio .NET will switch to code view and has added a default handler for the Form1_Load event. Add the following code inside the handler for a C# project:

or add this code for a VB.NET project:

That's all that's necessary to retrieve an image from the assembly and display it on the Picturebox control. Press F5 to run the program in either the Emulator or in your real device. This is what you'll see:

Figure 4 - The image is loaded from the assembly and displayed on the form

How It Works

The most interesting part of this example is the code that retrieves the image. The method GetManifestResourceStream does all the hard work, by retrieving the image from the current, or Executing assembly. Instead of just passing the filename, you'll need to pass the name of the Default Namespace or Root namespace and the name of the image. You'll find the Default Namespace on the Properties dialog of a C# project, while the Root namespace is found on the Properties dialog for a Visual Basic project. Even if your current class uses a different namespace, you'll still need to refer to the image using the default or root namespace.

Note that the Visual Basic .NET example uses the complete namespace to reference the Assembly class (System.Reflection.Assembly). By using the the full namespace, you no longer need to use the Imports statement at the top of the form. If you decide to leave out the System.Reflection prefix, you'll need to enclose the word Assembly in a pair of brackets:

If you leave out the brackets, you'll get a compile error because the Assembly class will not point to the one from the System.Reflection namespace.

When you have stored your images in separate folders (in a Project in VS.NET it's easy to create subfolders to group related files more logically together), you'll need to add the name of that folder between the default namespace and the name of the image, separated by a period. This applies only to C# projects:

This code will display an image that is embedded as DemoImage.gif in a subfolder called Demo which is located in the Images folder at the root of your project. For clarity, I split the first line of code over three lines. However, in your Visual Studio .NET project this could all be one line.

For Visual Basic, you can still use the same code I showed you earlier. Apparently Visual Basic handles the way images are stored in the assembly a bit different so there is no need to tell it where you stored the image.

Summary

Embedding images in the assembly is a convenient way to make sure that the image is always present at run-time. At first it may be a bit difficult to retrieve the images again, but with the code I showed you here that should now be moderately easy.
Take care not to store too large images in the assembly as this will slow down load times of your application. Try to optimize the images using your favorite graphics editor before you add them to save space. Alternatively, you can choose to deploy large images as separate files, together with your application.

Download Files

• Source Code for this Article in C#
• Source Code for this Article in VB.NET