IconExtractor.cs

using System;
using System.Drawing;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;
using be.gaudry.model.enums;
 
namespace be.gaudry.model.drawing
{
    /// <summary>
    /// Provides static methods to access Icons into executable files or dll.
    /// </summary>
    public class IconExtractor
    {
        #region declarations and constructor
 
        private static string shell32Path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), "shell32.dll");
        private static IntPtr hInst;
 
        static IconExtractor()
        {
            hInst = Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]);
        }
 
        #endregion
 
        #region marshall shell32 dll
        [DllImport("shell32.dll", EntryPoint = "ExtractAssociatedIcon")]
        private static extern IntPtr ExtractAssociatedIcon(
            IntPtr hInst,
            [MarshalAs(UnmanagedType.LPStr)] string lpIconPath,
            ref int lpiIcon);
 
        [DllImport("shell32.dll", EntryPoint = "ExtractIcon")]
        private static extern IntPtr ExtractIcon(
            IntPtr hInst,
            [MarshalAs(UnmanagedType.LPStr)] string lpszExeFileName,
            int nIconIndex); 
        #endregion
 
        #region public static methods
        /// <summary>
        /// Gets an Icon from the shell32.dll
        /// </summary>
        /// <param name="systemIcon">Icon identifier</param>
        /// <returns></returns>
        public static Icon getShell32Icon(SHELL32_ICON systemIcon)
        {
            try
            {
                return ExtractIcon(shell32Path, (int)systemIcon);
            }
            catch (Exception)
            {
                return null;
            }
        }
        /// <summary>
        /// Gets a Bitmap from the shell32.dll
        /// </summary>
        /// <param name="systemIcon">Icon identifier</param>
        /// <returns></returns>
        public static Bitmap getShell32Bitmap(SHELL32_ICON systemIcon)
        {
            try
            {
                return ExtractIcon(shell32Path, (int)systemIcon).ToBitmap();
            }
            catch (Exception)
            {
                switch (systemIcon)
                {
                    case SHELL32_ICON.goForwardSquare:
                        return global::be.gaudry.Properties.Resources.wizard_big;
                }
                return new Bitmap(1, 1);
            }
        }
        /// <summary>
        /// Gets the default Icon for an executable file or a dll
        /// </summary>
        /// <param name="fileName">Path of the executable file or a dll</param>
        /// <returns></returns>
        public static Icon ExtractAssociatedIcon(string fileName)
        {
            if (File.Exists(fileName) || Directory.Exists(fileName))
            {
                int i = 0;
 
                IntPtr hIcon = ExtractAssociatedIcon(hInst, fileName, ref i);
 
                if (!hIcon.Equals(IntPtr.Zero))
                {
                    return Icon.FromHandle(hIcon);
                }
                else
                {
                    return null;
                }
            }
            else
            {
                return null;
            }
        }
        /// <summary>
        /// Gets the first Icon of an executable file or a dll
        /// </summary>
        /// <param name="fileName">Path of the executable file or a dll</param>
        /// <returns></returns>
        public static Icon ExtractIcon(string fileName)
        {
            return ExtractIcon(fileName, 0);
        }
        /// <summary>
        /// Gets an Icon of an executable file or a dll
        /// </summary>
        /// <param name="fileName">Path of the executable file or a dll</param>
        /// <param name="index">position of the Icon in the Icons list in the file</param>
        /// <returns></returns>
        public static Icon ExtractIcon(string fileName, int index)
        {
            if (File.Exists(fileName) || Directory.Exists(fileName))
            {
                System.IntPtr hIcon;
 
                hIcon = ExtractIcon(hInst, fileName, -1);
 
                if (hIcon.Equals(IntPtr.Zero))
                {
                    return ExtractAssociatedIcon(fileName);
                }
                else
                {
                    int numOfIcons = hIcon.ToInt32();
 
                    if (0 <= index && index < numOfIcons)
                    {
                        hIcon = ExtractIcon(hInst, fileName, index);
 
                        if (!hIcon.Equals(IntPtr.Zero))
                        {
                            return Icon.FromHandle(hIcon);
                        }
                        else
                        {
                            return null;
                        }
                    }
                    else
                    {
                        return null;
                    }
                }
            }
            else
            {
                return null;
            }
        } 
        #endregion
    }
}