C#

using System;
using System.IO;
using System.Reflection;
using System.Drawing.Imaging;
 
public class ImageUtils
{
    /// <summary>
    /// Returns an ImageFormat which corresponds
    /// to the extension of the supplied filename.
    /// </summary>
    /// <param name="filename">
    /// The filename or extension of the image.
    /// </param>
    /// <returns>
    /// The ImageFormat for the filename.
    /// </returns>
    public static ImageFormat GetImageFormatForFile(string filename)
    {
        if (null == filename || 0 == filename.Length)
            throw new ArgumentNullException("filename");
    
        // Find the extension of the filename:
        int index = filename.IndexOf('.');
        string ext = (-1 == index) ? filename : filename.Substring(index + 1);
        ext = "*." + ext;
        
        // Find the ImageCodecInfo which matches the extension:
        ImageCodecInfo info = null;
        ImageCodecInfo[] codecs = ImageCodecInfo.GetImageEncoders();
        for(int i=0; i<codecs.Length && null == info; i++)
        {
            string[] extensions = codecs[i].FilenameExtension.Split(';');
            for(int j=0; j<extensions.Length && null == info; j++)
            {
                if (0 == string.Compare(extensions[j], ext, true))
                    info = codecs[i];
            }
        }
        
        // If we can't find the codec, there is no matching format
        if (null == info)
            return null;
        else
            return GetImageFormat(info.FormatID);
    }
    
    /// <summary>
    /// Returns the ImageFormat which corresponds
    /// to the specified MIME type.
    /// </summary>
    /// <param name="mimeType">
    /// The MIME type, e.g. "image/jpeg"
    /// </param>
    /// <returns>
    /// The ImageFormat for the MIME type.
    /// </returns>
    public static ImageFormat GetImageFormatForMime(string mimeType)
    {
        // Find the ImageCodecInfo which matches the MIME type:
        ImageCodecInfo info = null;
        ImageCodecInfo[] codecs = ImageCodecInfo.GetImageEncoders();
        for(int i=0; i<codecs.Length && null == info; i++)
        {
            if (0 == string.Compare(codecs[i].MimeType, mimeType, true))
                info = codecs[i];
        }
        
        // If we can't find the codec, there is no matching format
        if (null == info)
            return null;
        else
            return GetImageFormat(info.FormatID);
    }
    
    /// <summary>
    /// Returns the ImageFormat instance for the
    /// specified format ID. Uses reflection to
    /// test the static instances of the class
    /// for the correct ID, before using the
    /// constructor.
    /// </summary>
    /// <param name="formatID">
    /// The Guid which contains the format ID.
    /// </param>
    /// <returns>
    /// The corresponding ImageFormat object.
    /// </returns>
    public static ImageFormat GetImageFormat(Guid formatID)
    {
        // Find the matching image format
        // The image formats are stored as static properties
        // of the ImageFormat class.
        Type tImageFormat = typeof(ImageFormat);
        PropertyInfo[] props = tImageFormat.GetProperties(
            BindingFlags.Public | BindingFlags.Static);
        
        for(int i=0; i<props.Length; i++)
        {
            PropertyInfo prop = props[i];
            if (tImageFormat == prop.PropertyType)
            {
                // This is an ImageFormat property
                ImageFormat fmt = (ImageFormat)prop.GetValue(null, null);
                if (fmt.Guid == formatID)
                    return fmt;
            }
        }
        
        // None of the static ImageFormat properties matched,
        // so use the FormatID to create a new format:
        return new ImageFormat(formatID);
    }
}