C# – How Do I Extract a Full Icon From a Vista/7 Executable

Today, I made a very nice function for extracting the 256x256 Bitmaps from Vista icons.

I use it to display the large icon ( 256x256 ) as a Bitmap in "About" box. For example, this code gets Vista icon as PNG image, and displays it in a 256x256 PictureBox:

picboxAppLogo.Image = ExtractVistaIcon(Icon.ExtractAssociatedIcon(myIcon));

This function takes Icon object as a parameter. So, you can use it with any icons - from resources, from files, from streams, and so on. (Read below about extracting EXE icon).

It runs on any OS, because it does not use any Win32 API, it is 100% managed code :-)

// Based on: http://www.codeproject.com/KB/cs/IconExtractor.aspx
// And a hint from: http://www.codeproject.com/KB/cs/IconLib.aspx

Bitmap ExtractVistaIcon(Icon icoIcon)
{
    Bitmap bmpPngExtracted = null;
    try
    {
        byte[] srcBuf = null;
        using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
            { icoIcon.Save(stream); srcBuf = stream.ToArray(); }
        const int SizeICONDIR = 6;
        const int SizeICONDIRENTRY = 16;
        int iCount = BitConverter.ToInt16(srcBuf, 4);
        for (int iIndex=0; iIndex<iCount; iIndex++)
        {
            int iWidth  = srcBuf[SizeICONDIR + SizeICONDIRENTRY * iIndex];
            int iHeight = srcBuf[SizeICONDIR + SizeICONDIRENTRY * iIndex + 1];
            int iBitCount   = BitConverter.ToInt16(srcBuf, SizeICONDIR + SizeICONDIRENTRY * iIndex + 6);
            if (iWidth == 0 && iHeight == 0 && iBitCount == 32)
            {
                int iImageSize   = BitConverter.ToInt32(srcBuf, SizeICONDIR + SizeICONDIRENTRY * iIndex + 8);
                int iImageOffset = BitConverter.ToInt32(srcBuf, SizeICONDIR + SizeICONDIRENTRY * iIndex + 12);
                System.IO.MemoryStream destStream = new System.IO.MemoryStream();
                System.IO.BinaryWriter writer = new System.IO.BinaryWriter(destStream);
                writer.Write(srcBuf, iImageOffset, iImageSize);
                destStream.Seek(0, System.IO.SeekOrigin.Begin);
                bmpPngExtracted = new Bitmap(destStream); // This is PNG! :)
                break;
            }
        }
    }
    catch { return null; }
    return bmpPngExtracted;
}

IMPORTANT! If you want to load this icon directly from EXE file, then you CAN'T use Icon.ExtractAssociatedIcon(Application.ExecutablePath) as a parameter, because .NET function ExtractAssociatedIcon() is so stupid, it extracts ONLY 32x32 icon!

Instead, you better use the whole IconExtractor class, created by Tsuda Kageyu (http://www.codeproject.com/KB/cs/IconExtractor.aspx). You can slightly simplify this class, to make it smaller. Use IconExtractor this way:

// Getting FILL icon set from EXE, and extracting 256x256 version for logo...
using (TKageyu.Utils.IconExtractor IconEx = new TKageyu.Utils.IconExtractor(Application.ExecutablePath))
{
    Icon icoAppIcon = IconEx.GetIcon(0); // Because standard System.Drawing.Icon.ExtractAssociatedIcon() returns ONLY 32x32.
    picboxAppLogo.Image = ExtractVistaIcon(icoAppIcon);
}

Note: I'm still using my ExtractVistaIcon() function here, because I don't like how IconExtractor handles this job - first, it extracts all icon formats by using IconExtractor.SplitIcon(icoAppIcon), and then you have to know the exact 256x256 icon index to get the desired vista-icon. So, using my ExtractVistaIcon() here is much faster and simplier way :)

The ResourceManager loads the icon based on the bits stored in the resources. However, the way it handles loading won't let you access the 256x256 icon (this information does not make its way into the System.Drawing.Icon that you are getting back).

I am sorry to disappoint you, but the only way which works that I am aware of is to load the icon through a P/Invoke of LoadImage and working with a file (yes, I know, that's not what you were looking for). So the new question should be: how do I extract the bits of a given resource so that I can store them to a file? I fear that this isn't possible either, having done some stepping through System.Resources.ResourceReader, as the resource data seems to be a collection of serialized .NET objects.

Anyway, for those who can afford to load the icon from a .ICO file (and for myself, as a future reference on how to load 256x256 icons), call IconConverter.LoadIcon:

using System.Runtime.InteropServices;

static class IconConverter
{
    public static System.Drawing.Icon LoadIcon(string path, int width, int height)
    {
        System.IntPtr hIcon;
        hIcon = LoadImage (System.IntPtr.Zero, path, IMAGE_ICON, width, height,
                           LR_LOADFROMFILE);
        if (hIcon == System.IntPtr.Zero)
        {
            return null;
        }
        return System.Drawing.Icon.FromHandle (hIcon);
    }

    const int IMAGE_ICON = 1;
    const int LR_LOADFROMFILE = 0x0010;

    [DllImport ("user32.dll", SetLastError=true, CharSet=CharSet.Auto)]
    static extern System.IntPtr LoadImage(System.IntPtr hInstance,
                                          string lpszName, uint uType,
                                          int cxDesired, int cyDesired,
                                          uint fuLoad);
}

Once you have the System.Drawing.Icon in the expected size, just paint it using graphics.DrawIconUnstretched.