Click here to Skip to main content
Click here to Skip to main content

An extensible ExifReader class with customizable tag handlers

, 29 Mar 2010 CPOL
Rate this:
Please Sign up or sign in to vote.
An ExifReader class in C# that supports custom formatting and extraction. StyleCop compliant code, with demos for WPF and Windows Forms.

Figure 1: WPF-MVVM Demo App

Figure 2: Windows Forms Demo App

Introduction

I needed an Exif reader class for a C# application I was working on, and though I found quite a few implementations available including a few on The Code Project, none of them fully suited my requirements. So I wrote my own class. This article describes the use and implementation of this class, and also includes a couple of demo projects, one using Windows Forms and the PropertyGrid, and another using WPF and the growingly popular MVVM architecture. The ExifReader project is 100% Style Cop compliant except for the IDE generated AssemblyInfo.cs and the PropertyTagId.cs file which I custom created from multiple sources including some GDI+ header files, as well as trial and error. I didn't think it would be a great idea to try and apply Style Cop guidelines to either of those files. The class does not directly access Exif metadata from image files, and instead delegates that functionality to the Image class from System.Drawing. The public interface does not expose any System.Drawing types and so this library can be used from WPF without needing to reference System.Drawing.

Note to readers/users of this class

This class tries to cover as many of the documented and undocumented Exif tags as I could test on, but if any of you encounter images that have Exif tags that are not recognized by my class, I request you to kindly contact me and send me the images. Once I have the images, I can attempt to support those tags too. Right now, if it encounters an undocumented tag it will still extract the tag value, but you won't see any descriptive tag-name or any custom parsing/formatting that may be required.

Code was written on VS 2010 and .NET 4.0

All the code, including the demos, have been written and tested on VS 2010 RC and .NET 4.0. While I have not intentionally used any .NET 4.0/C# 4.0 only feature like say the dynamic keyword, I may have inadvertently written code that may not compile in .NET 3.5. But I don't expect any of those to be hard to fix or change for most programmers, but if you run into trouble and can't figure out what to do, please ping me via the article forum and I'll help fix it. I suspect the most common compatibility issues would be with regard to IEnumerable<T> cast requirements in .NET 3.5, since it became a variant interface only in .NET 4.0.

Inline code formatting

The inline code snippets in this article have been wrapped for easier viewing. The actual code in the source files don't assume that you are using a 10 inch Netbook. *grin*

Using the ExifReader class

If you are using an Exif reader class, I guess it's safe to assume that you are familiar with Exif properties and the Exif specification. So I won't go into the details. For those who are interested, here are two good links:

The second link includes the Exif 2.2 specification. The 2.21 specification is not available for free download, though there are sites where you can purchase it. You will also find that many cameras and phones insert Exif 2.21 tags even though the Exif version tag is still set to 2.2, and you will also find that applications like Adobe Photoshop insert their own custom tags. Camera manufacturers like Nikon and Canon have their own proprietary tags too. I have basically stuck to the standard tags and have not attempted to decipher any of the company proprietary tags, though it's possible that a future version may support those too.

The class interface is fairly trivial, all you do is instantiate an ExifReader object passing a file path, and then access the extracted Exif properties with a call to GetExifProperties. Here's some example code:

internal class Program
{
    internal static void Main(string[] args)
    {
        ExifReader exifReader = new ExifReader(
            @"C:\Users\Public\Pictures\Sample Pictures\Jellyfish.jpg");        

        foreach (ExifProperty item in exifReader.GetExifProperties())
        {
            Console.WriteLine("{0} = {1}", item.ExifPropertyName, item);
        }

        Console.ReadKey();
    }
}

The ExifProperty type will be described in a little more detail in the next two sections where I talk about the two demo applications. Essentially it's the only other type you'll have to deal with when using the ExifReader class. You can further dig into the property data by using ExifProperty.ExifValue if you need to as shown below, but it's an unlikely scenario unless you are dealing with a custom Exif tag type unique to your application, or if it's an unhandled proprietary tag as those from Nikon, Canon, or Adobe, in which case you may want to access the values directly and do your own interpretation or formatting.

ExifProperty copyRight = exifReader.GetExifProperties().Where(
    ep => ep.ExifTag == PropertyTagId.Copyright).FirstOrDefault();

if (copyRight != null)
{
    Console.WriteLine(copyRight.ExifValue.Count);
    Console.WriteLine(copyRight.ExifValue.ValueType);

    foreach (var value in copyRight.ExifValue.Values)
    {
        Console.WriteLine(value);                    
    }
}

PropertyTagId is an enum that represents the documented Exif-Tag properties as well as a few undocumented ones. There is also a PropertyTagType enum that represents the Exif data type. Both these enumerations will be discussed in later sections of the article.

Using custom formatters and extractors

The ExifReader supports custom handling of tags, which is useful not just for undocumented tags that are not automatically handled by the class, but also for specialized handling of documented tags. There are two events QueryUndefinedExtractor and QueryPropertyFormatter that you need to handle, and these events allow you to specify a custom formatter object as well as a custom extractor object. Note that it's usually convenient but not necessary to implement both the formatter and the extractor in a single class. Also be aware that if you provide a custom extractor for a documented tag, then it's highly recommended that you also implement a custom formatter, specially if you change the extracted data type of the property. Here's an example of a very simple tag handler class.

class MyCustomExifHandler 
  : IExifPropertyFormatter, IExifValueUndefinedExtractor
{
    public string DisplayName
    {
        get { return "My Display Name"; }
    }

    public string GetFormattedString(IExifValue exifValue)
    {
        return String.Concat("Formatted version of ", 
          exifValue.Values.Cast<string>().First());
    }

    public IExifValue GetExifValue(byte[] value, int length)
    {
        string bytesString = String.Join(" ", 
          value.Select(b => b.ToString("X2")));
        return new ExifValue<string>(
          new[] { String.Concat("MyValue = ", bytesString) });
    }
}

Both the implemented interfaces will be discussed later in this article. Once you have a custom handler class, you can handle the events and set the appropriate values on the EventArgs object.

ExifReader exifReader = new ExifReader(@". . .");

MyCustomExifHandler exifHandler = new MyCustomExifHandler();

exifReader.QueryUndefinedExtractor += (sender, e) => 
{
    if (e.TagId == 40093)
    {
        e.UndefinedExtractor = exifHandler;
    }
};

exifReader.QueryPropertyFormatter += (sender, e) =>
{
    if (e.TagId == 40093)
    {
        e.PropertyFormatter = exifHandler;
    }
};

foreach (ExifProperty item in exifReader.GetExifProperties())
{
    . . .
}

Notice how it's of extreme importance to check the TagId. If you do not do this, you will be applying your custom formatter or extractor to every single Exif tag that's extracted from the image and that's guaranteed to end in disaster!

Demo app for Windows Forms

The Windows Forms demo uses a PropertyGrid to show the various Exif properties. The ExifReader has built-in support for the PropertyGrid control, so there is very little code you need to write. Here's the entire user-written code in the Windows Forms demo project:

/// <summary>
/// Event handler for Browse button Click.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">Event arguments.</param>
private void ButtonBrowse_Click(object sender, EventArgs e)
{
    using (OpenFileDialog dialog = new OpenFileDialog()
        {
            Filter = "Image Files(*.PNG;*.JPG)|*.PNG;*.JPG;"
        })
    {
        if (dialog.ShowDialog() == DialogResult.OK)
        {
            try
            {
                ExifReader exifReader = new ExifReader(dialog.FileName);
                this.propertyGridExif.SelectedObject = exifReader;
                this.pictureBoxPreview.ImageLocation = dialog.FileName;
            }
            catch (ExifReaderException ex)
            {
                MessageBox.Show(ex.Message, "ExifReaderException was caught");
            }
        }
    }
}

The highlighted line shows where we associate the ExifReader object with the PropertyGrid control. Figure 2 shows a screenshot of what the app would look like when run and an image is selected. The reason this works this way is that the ExifReader class has a custom TypeDescriptionProvider which dynamically provides the property descriptors that the PropertyGrid looks for. I've talked a little about how this has been implemented down below in the Implementation Details section. From a Windows Forms perspective, if you have a form where you need to display the Exif properties, this would be the simplest way to go about doing it. Drop a PropertyGrid control on the form and then set the SelectedObject to an ExifReader instance, and that's all you need to do.

Handling exceptions

Notice how an exception of type ExifReaderException is caught and handled. The ExifReader's constructor is the only place where this exception is directly thrown. Exception handling is discussed in multiple places in the article, but in brief, you typically get this exception here if a file path is invalid or an image file is corrupt or has invalid Exif metadata. Once the ExifReader is instantiated, you will never get a direct exception of type ExifReaderException. The data binding (whether in WinForms or WPF) will primarily be via property accessors and the ToString override, and thus throwing arbitrary exception objects from these locations is not recommended and quite against standard .NET practices. From all these places, what's thrown is an exception of type InvalidOperationException which the majority of well-written data binding libraries know how to handle correctly. You can still handle this exception in the debugger and access the source ExifReaderException object via the InnerException property of the InvalidOperationException object.

Demo app for WPF/MVVM

Three gentlemen by the names of Josh Smith, Sacha Barber, and Pete O'Hanlon have been saying good things about MVVM here on The Code Project for at least a couple of years now, and so I thought it would be a good idea to apply it for the WPF demo app, even though the entire app is of a very simplistic nature. Of course my implementation is rather plain and lacks the finesse and poise that we now take for granted in articles and applications written by the afore mentioned gentlemen. While it's not an absolute requisite that the View class is 100% Xaml with zero code-behind, since this was my first MVVM app, I went out of my way to make sure that there is no code-behind in use. While it's not connected with the ExifReader per se, I will still briefly run through what I did to do what I wanted to do.

Figure 3: WPF-MVVM app with filter applied

The WPF demo does a little more than the WinForms demo. For one thing, it shows the Exif data type and the Exif tag name for each extracted tag. And then for another, it supports the ability to filter results using a search keyword that searches the tag name as well as the tag property value. And then there's also the fact that my demo app portrays my absolutely horrid sense of color schemes, styles, and UI themes. I always give Sacha a hard time regarding his rather unorthodox ideas on colors and styles, but I think I've surpassed even Sacha in poor UI taste. *grin*

The ViewModel class

There's only one ViewModel class for this demo project, and it has commands for browse, exit, and filter. There is also a public CollectionViewSource property called ExifProperties which returns the extracted Exif properties. Initially this was an ObservableCollection<ExifProperty> property but I had to change it to a CollectionViewSource property to adamantly stick with my decision to avoid code-behind in the view class. Since I wanted to do filtering, this was the simplest way I could use the built-in filtering support of the CollectionViewSource entirely inside the ViewModel class.

internal class MainViewModel : INotifyPropertyChanged
{
    private ICommand browseCommand;

    private ICommand exitCommand;

    private ICommand filterCommand;

    private string searchText = String.Empty;

    private ObservableCollection<ExifProperty> exifPropertiesInternal 
        = new ObservableCollection<ExifProperty>();

    private CollectionViewSource exifProperties = new CollectionViewSource();

    private ImageSource previewImage;

    public MainViewModel()
    {
        exifProperties.Source = exifPropertiesInternal;
        exifProperties.Filter += ExifProperties_Filter;
    }

    public CollectionViewSource ExifProperties
    {
        get { return exifProperties; }
    }

    public ICommand BrowseCommand
    {
        get
        {
            return browseCommand ?? 
              (browseCommand = new DelegateCommand(BrowseForImage));
        }
    }

    public ICommand ExitCommand
    {
        get
        {
            return exitCommand ?? 
              (exitCommand = new DelegateCommand(
                () => Application.Current.Shutdown()));
        }
    }

    public ICommand FilterCommand
    {
        get
        {
            return filterCommand ?? 
              filterCommand = new DelegateCommand(
                () => exifProperties.View.Refresh()));
        }
    }

    public ImageSource PreviewImage
    {
        get
        {
            return previewImage;
        }

        set
        {
            if (previewImage != value)
            {
                previewImage = value;
                FirePropertyChanged("PreviewImage");
            }
        }
    }

    public string SearchText
    {
        get
        {
            return searchText;
        }

        set
        {
            if (searchText != value)
            {
                searchText = value;
                FirePropertyChanged("SearchText");
            }
        }
    }

    private void BrowseForImage()
    {
        // <snipped>
    }

    private void ExifProperties_Filter(object sender, FilterEventArgs e)
    {
        // <snipped>
    }

    public event PropertyChangedEventHandler PropertyChanged;

    private void FirePropertyChanged(string propertyName)
    {
        PropertyChangedEventHandler handler = PropertyChanged;

        if (handler != null)
        {
            handler(this, new PropertyChangedEventArgs(propertyName));
        }
    }
}

Here's the code where the image is browsed to, and the ExifReader instantiated. All the extracted properties are added to the ObservableCollection<ExifProperty> property, and the preview image is appropriately set.

private void BrowseForImage()
{
    OpenFileDialog fileDialog = new OpenFileDialog()
        {
            Filter = "Image Files(*.PNG;*.JPG)|*.PNG;*.JPG;"
        };

    if (fileDialog.ShowDialog().GetValueOrDefault())
    {
        try
        {
            ExifReader exifReader = new ExifReader(fileDialog.FileName);
            exifPropertiesInternal.Clear();
            this.SearchText = String.Empty;
            foreach (var item in exifReader.GetExifProperties())
            {
                exifPropertiesInternal.Add(item);
            }

            this.PreviewImage = new BitmapImage(new Uri(fileDialog.FileName));
        }
        catch (ExifReaderException ex)
        {
            MessageBox.Show(ex.Message, "ExifReaderException was caught");
        }
    }
}

Note how similar to the WinForms demo, there's a try-catch handler specifically for an exception of type ExifReaderException. For most apps, you may want to filter out specific tags at this point, or maybe only show some pre-selected list of Exif properties. Either way there's nothing there that a couple of lines of LINQ won't solve. I did consider adding built-in support for filtering within the ExifReader class but then decided it deviates from the core class functionality, and does not really have a lot of value anyway since the user can do that in one or two lines of code. For the demo app, the filter is text-based and does a case insensitive search on the Exif property name as well as the property value's string representation.

private void ExifProperties_Filter(object sender, FilterEventArgs e)
{
    ExifProperty exifProperty = e.Item as ExifProperty;
    if (exifProperty == null)
    {
        return;
    }

    foreach (string body in new[] { 
      exifProperty.ExifPropertyName, 
      exifProperty.ExifTag.ToString(), exifProperty.ToString() })
    {
        e.Accepted = body.IndexOf(
          searchText, StringComparison.OrdinalIgnoreCase) != -1;

        if (e.Accepted)
        {
            break;
        }
    }
}

The View

The view is the main Window class in the project (I did say this was a rather crude MVVM implementation, so don't smirk too much). There's a ListBox with a data template applied that displays the Exif properties. Here's some partially snipped, and heavily word wrapped Xaml code:

<ListBox Grid.Column="1" ItemsSource="{Binding ExifProperties.View}" 
     Background="Transparent" TextBlock.FontSize="11"
     ScrollViewer.HorizontalScrollBarVisibility="Disabled" 
     VerticalContentAlignment="Stretch" HorizontalAlignment="Stretch">

    . . .

    <ListBox.ItemTemplate>
        <DataTemplate>

            <dropShadow:SystemDropShadowChrome CornerRadius="20,20,0,0">
                <StackPanel Orientation="Vertical" Margin="5" Width="240" 
                  Background="Transparent">

                    <Border CornerRadius="20,20,0,0" Background="#FF0D3C83" 
                      x:Name="topPanel">
                        <StackPanel Orientation="Horizontal" Margin="6,0,0,0">
                            <TextBlock x:Name="titleText" 
                              Text="{Binding ExifPropertyName}" 
                              Foreground="White" FontWeight="Bold" />
                        </StackPanel>
                    </Border>

                    <StackPanel Orientation="Vertical" 
                      Background="#FF338DBE" x:Name="mainPanel">
                        <StackPanel Orientation="Horizontal">
                            <TextBlock Text="Exif Tag: " 
                              FontWeight="Bold" MinWidth="100" />
                            <TextBlock Text="{Binding ExifTag}" />
                        </StackPanel>
                        <StackPanel Orientation="Horizontal">
                            <TextBlock Text="Exif Datatype: " 
                              FontWeight="Bold" MinWidth="100" />
                            <TextBlock Text="{Binding ExifDatatype}" />
                        </StackPanel>
                        <StackPanel Orientation="Horizontal">
                            <TextBlock Text="Property Value: " 
                              FontWeight="Bold" MinWidth="100" />
                            <TextBlock Text="{Binding}" />
                        </StackPanel>
                    </StackPanel>

                </StackPanel>
            </dropShadow:SystemDropShadowChrome>

            . . .

        </DataTemplate>
    </ListBox.ItemTemplate>

    <ListBox.ItemsPanel>
        <ItemsPanelTemplate>
            <WrapPanel />
        </ItemsPanelTemplate>
    </ListBox.ItemsPanel>
</ListBox>

I've removed the superfluous styling code. The binding points in code are highlighted above, and the reason the property value binds to self is that the ExifProperty class has a ToString override - which makes it trouble-free to render readable text for the Exif property values. In fact the Windows Forms PropertyGrid uses ToString too and this ensures that you'll see consistent display values irrespective of how you use the class.

I wanted the filtering to be live, as in the filter should take effect as the user types into the text box. The big problem with this is that the TextBox does not have a Command property, and thus I'd need to use code-behind to proxy its text changed event to the ViewModel. And I did not want to do that. Once again this was purely whimsical behavior on my part since MVVM does not mandate this at all, though a lot of people do recommend it. Apparently, you can get around this by referencing an Expression Blend DLL, which has support for interaction triggers that you can forward to a command object, thereby avoiding any code-behind. I didn't want to reference an Expression Blend DLL, not for a simple demo app anyway and so I was forced to work around it by adding an attached behavior to the TextBox that could take a command object. This was total over-kill of course, and in a real world app I'd simply do it in code-behind. Most likely something like :

ViewModel viewModel = this.DataContext as ViewModel;

. . . 

private void TextChanged(. . .)
{
    viewModel.SomeCommand(. . .) ;
}

That'd be in my view's code-behind, and while some purists may not be too happy, I think it's definitely simpler than referencing Expression Blend! And to paraphrase Rama Vavilala's words : "after all, these frameworks are supposed to make things simpler". Here's the Xaml code snippet:

<TextBox x:Name="searchTextBox" Width="165"  
  HorizontalAlignment="Left" Margin="3,0,0,0"
  Text="{Binding SearchText}" 
  local:TextChangedBehavior.TextChanged="{Binding FilterCommand}" />

Instead of handling the TextChanged event, I handle it via the attached behavior and route it to the FilterCommand command object in the ViewModel. Here's the code for the attached behavior:

internal class TextChangedBehavior
{
    public static DependencyProperty TextChangedCommandProperty 
        = DependencyProperty.RegisterAttached(
          "TextChanged", 
          typeof(ICommand), 
          typeof(TextChangedBehavior),
          new FrameworkPropertyMetadata(
            null, 
            new PropertyChangedCallback(
              TextChangedBehavior.TextChangedChanged)));

    public static void SetTextChanged(TextBox target, ICommand value)
    {
        target.SetValue(TextChangedBehavior.TextChangedCommandProperty, 
          value);
    }

    public static ICommand GetTextChanged(TextBox target)
    {
        return (ICommand)target.GetValue(TextChangedCommandProperty);
    }

    private static void TextChangedChanged(
      DependencyObject target, DependencyPropertyChangedEventArgs e)
    {
        TextBox element = target as TextBox;

        if (element != null)
        {
            if (e.NewValue != null)
            {
                element.TextChanged += Element_TextChanged;
            }
            else
            {
                element.TextChanged -= Element_TextChanged;
            }
        }
    }

    static void Element_TextChanged(object sender, TextChangedEventArgs e)
    {
        TextBox textBox = (TextBox)sender;
        BindingExpression bindingExpression = textBox.GetBindingExpression(
          TextBox.TextProperty);

        if (bindingExpression != null)
        {                
            bindingExpression.UpdateSource();
        } 

        ICommand command = GetTextChanged(textBox);

        if (command.CanExecute(null))
        {
            command.Execute(null);
        }
    }
}

Nothing complicated there, just a basic attached behavior implementation. The highlighted code shows where we proxy to the actual command implementation.

ExifReader Class Reference

As I already mentioned, except for that one enum source file, the rest of the ExifReader code is fully StyleCop compliant, and thus I had to add XML comments for every method, property, and field, including private ones. So the code is basically self documenting for the most part. Once again the code snippets below are line wrapped for viewing, so some of the comment lines will seem rather awkwardly split up into multiple lines.

The ExifReader class

/// <summary>
/// This is the implementation of the ExifReader class that 
/// reads EXIF data from image files.
/// It partially supports the Exif Version 2.2 standard.
/// </summary>
[TypeDescriptionProvider(typeof(ExifReaderTypeDescriptionProvider))]
public class ExifReader
{
    /// <summary>
    /// List of Exif properties for the image.
    /// </summary>
    private List<ExifProperty> exifproperties;

    /// <summary>
    /// The Image object associated with the image file
    /// </summary>
    private Image imageFile;

    /// <summary>
    /// Initializes a new instance of the ExifReader class based on a file path.
    /// </summary>
    /// <param name="imageFileName">Full path to the image file</param>
    public ExifReader(string imageFileName);

    /// <summary>
    /// Occurs when the class needs to query for a property formatter
    /// </summary>
    public event EventHandler<
      QueryPropertyFormatterEventArgs> QueryPropertyFormatter;

    /// <summary>
    /// Occurs when the class needs to query for an undefined extractor
    /// </summary>
    public event EventHandler<
      QueryUndefinedExtractorEventArgs> QueryUndefinedExtractor;

    /// <summary>
    /// Returns a read-only collection of all the Exif properties
    /// </summary>
    /// <returns>The Exif properties</returns>
    public ReadOnlyCollection<ExifProperty> GetExifProperties();

    /// <summary>
    /// Checks to see if a custom property formatter is available
    /// </summary>
    /// <param name="tagId">The tag Id to check for a formatter</param>
    /// <returns>An IExifPropertyFormatter or null 
    /// if there's no formatter available</returns>
    internal IExifPropertyFormatter QueryForCustomPropertyFormatter(int tagId);

    /// <summary>
    /// Checks to see if a custom undefined extractor is available
    /// </summary>
    /// <param name="tagId">The tag Id to check for an extractor</param>
    /// <returns>An IExifValueUndefinedExtractor or null 
    /// if there's no formatter available</returns>
    internal IExifValueUndefinedExtractor 
      QueryForCustomUndefinedExtractor(int tagId);

    /// <summary>
    /// Fires the QueryPropertyFormatter event
    /// </summary>
    /// <param name="eventArgs">Args data for the 
    /// QueryPropertyFormatter event</param>
    private void FireQueryPropertyFormatter(
      QueryPropertyFormatterEventArgs eventArgs);

    /// <summary>
    /// Fires the QueryUndefinedExtractor event
    /// </summary>
    /// <param name="eventArgs">Args data for the 
    /// QueryUndefinedExtractor event</param>
    private void FireQueryUndefinedExtractor(
      QueryUndefinedExtractorEventArgs eventArgs);

    /// <summary>
    /// Initializes the Exif properties for the associated image file
    /// </summary>
    private void InitializeExifProperties();
}

Earlier on, I had a constructor overload that took an Image argument but it was removed so that WPF projects can reference the DLL without needing to reference the System.Drawing DLL.

The QueryPropertyFormatterEventArgs class

/// <summary>
/// Provides data for the QueryPropertyFormatter event
/// </summary>
public class QueryPropertyFormatterEventArgs : EventArgs
{
    /// <summary>
    /// Initializes a new instance of the 
    /// QueryPropertyFormatterEventArgs class.
    /// </summary>
    /// <param name="tagId">The tag Id to query 
    /// a property formatter for</param>
    public QueryPropertyFormatterEventArgs(int tagId);

    /// <summary>
    /// Gets or sets the associated property formatter
    /// </summary>
    public IExifPropertyFormatter PropertyFormatter { get; set; }

    /// <summary>
    /// Gets the associated tag Id
    /// </summary>
    public int TagId { get; private set; }
}

The QueryUndefinedExtractorEventArgs class

/// <summary>
/// Provides data for the QueryUndefinedExtractor event
/// </summary>
public class QueryUndefinedExtractorEventArgs : EventArgs
{
    /// <summary>
    /// Initializes a new instance of the 
    /// QueryUndefinedExtractorEventArgs class.
    /// </summary>
    /// <param name="tagId">The tag Id to query a 
    /// property formatter for</param>
    public QueryUndefinedExtractorEventArgs(int tagId);

    /// <summary>
    /// Gets or sets the associated property formatter
    /// </summary>
    public IExifValueUndefinedExtractor UndefinedExtractor { get; set; }

    /// <summary>
    /// Gets the associated tag Id
    /// </summary>
    public int TagId { get; private set; }
}

I considered unifying the above two EventArgs classes into a single generic class, but then decided to retain them as separate classes since they are both used in public event handlers where I feel clarity is more important than compactness.

The ExifProperty class

/// <summary>
/// Represents an Exif property.
/// </summary>
public class ExifProperty
{
    /// <summary>
    /// The PropertyItem associated with this object.
    /// </summary>
    private PropertyItem propertyItem;

    /// <summary>
    /// The IExifValue associated with this object.
    /// </summary>
    private IExifValue exifValue;

    /// <summary>
    /// The IExifPropertyFormatter for this property.
    /// </summary>
    private IExifPropertyFormatter propertyFormatter;

    /// <summary>
    /// Set to true if this object represents an unknown property tag
    /// </summary>
    private bool isUnknown;

    /// <summary>
    /// Set to true if this object has a custom property formatter
    /// </summary>
    private bool hasCustomFormatter;

    /// <summary>
    /// The parent ExifReader that owns this ExifProperty object
    /// </summary>
    private ExifReader parentReader;

    /// <summary>
    /// Initializes a new instance of the ExifProperty class.
    /// It's marked internal  as it's not intended to be 
    /// instantiated independently outside of the library.
    /// </summary>
    /// <param name="propertyItem">The PropertyItem to 
    /// base the object on</param>
    /// <param name="parentReader">The parent ExifReader</param>
    internal ExifProperty(PropertyItem propertyItem, ExifReader parentReader);

    /// <summary>
    /// Gets the IExifValue for this property
    /// </summary>
    public IExifValue ExifValue;

    /// <summary>
    /// Gets the descriptive name of the Exif property
    /// </summary>
    public string ExifPropertyName;

    /// <summary>
    /// Gets a category name for the property.
    /// Note: This is not part of the Exif standard 
    /// and is merely for convenience.
    /// </summary>
    public string ExifPropertyCategory;

    /// <summary>
    /// Gets the Exif property tag Id for this property
    /// </summary>
    public PropertyTagId ExifTag;

    /// <summary>
    /// Gets the Exif data type for this property
    /// </summary>
    public PropertyTagType ExifDatatype;

    /// <summary>
    /// Gets the raw Exif tag. For unknown tags this will not
    /// match the value of the ExifTag property.
    /// </summary>
    public int RawExifTagId;

    /// <summary>
    /// Override for ToString
    /// </summary>
    /// <returns>Returns a readable string representing 
    /// the Exif property's value</returns>
    public override string ToString();

    /// <summary>
    /// Gets the formatted string using the property formatter
    /// </summary>
    /// <returns>The formatted string</returns>
    private string GetFormattedString();

    /// <summary>
    /// Initializes the exifValue field.
    /// </summary>
    /// <returns>The initialized exifValue</returns>
    private IExifValue InitializeExifValue();

    /// <summary>
    /// Returns an ExifReaderException set with the current property formatter
    /// </summary>
    /// <param name="ex">Inner exception object</param>
    /// <returns>The ExifReaderException object</returns>
    private ExifReaderException GetExifReaderException(Exception ex);
}

The IExifValue interface

    /// <summary>
    /// This interface represents an Exif property value
    /// </summary>
    public interface IExifValue
    {
        /// <summary>
        /// Gets the type of the Exif property value or values
        /// </summary>
        Type ValueType { get; }

        /// <summary>
        /// Gets the number of values
        /// </summary>
        int Count { get; }

        /// <summary>
        /// Gets a type-unsafe collection of values of a specific 
        /// Exif tag data type
        /// </summary>
        IEnumerable Values { get; }
    }

Normal usage would not require accessing the ExifProperty.ExifValue property, but this is provided for custom interpretation of undocumented or proprietary tags. Note how the IExifValue interface actually returns a System.Type for the ValueType property. I designed it thus since the IExifValue represents how the value is represented internally by the ExifReader class and not an actual byte-based representation of the native Exif data. The user can still access ExifProperty.ExifDatatype to get the Exif data type associated with the property.

The PropertyTagType enumeration

/// <summary>
/// Defines the various Exif property tag type values
/// </summary>
public enum PropertyTagType
{
    /// <summary>
    /// An 8-bit unsigned integer
    /// </summary>
    Byte = 1,

    /// <summary>
    /// A NULL terminated ASCII string
    /// </summary>
    ASCII = 2,

    /// <summary>
    /// A 16-bit unsigned integer
    /// </summary>
    Short = 3,

    /// <summary>
    /// A 32-bit unsigned integer
    /// </summary>
    Long = 4,

    /// <summary>
    /// Two LONGs. The first is the numerator and the 
    /// second the denominator
    /// </summary>
    Rational = 5,

    /// <summary>
    /// An 8-bit byte that can take any value depending on 
    /// the field definition
    /// </summary>
    Undefined = 7,

    /// <summary>
    /// A 32-bit signed integer 
    /// </summary>
    SLong = 9,

    /// <summary>
    /// Two SLONGs. The first SLONG is the numerator and 
    /// the second the denominator
    /// </summary>
    SRational = 10
}

The PropertyTagId enumeration

/// <summary>
/// Defines the common Exif property Ids
/// </summary>
/// <remarks>
/// This is not a comprehensive list since there are several 
/// non-standard Ids in use (example those from Adobe)
/// </remarks>
public enum PropertyTagId
{
    GpsVer = 0x0000,

    GpsLatitudeRef = 0x0001,
    
    . . .
    
    <snipped>

This is too long to list here in its entirety, so please refer to the source code. I do discuss a little about how I've used this enum in the whole Exif extraction process in the next section. I have added one special value here to represent tags that I do not recognize, and I've chosen the largest 16 bit value possible that I hope will not coincide with an actual Exif tag value used by some proprietary Exif format.

[EnumDisplayName("Unknown Exif Tag")]
UnknownExifTag = 0xFFFF

I was originally casting the integer value to the enum because WinForms and its PropertyGrid did not complain about invalid enum values, and ToString would just return the numeric string value which was all perfectly okay. Strictly speaking WPF did not complain either, but I saw a first-chance exception in the output window and traced it down to the fact that the default WPF data binding uses the internal class SourceDefaultValueConverter from PresentationFramework which was throwing an ArgumentException when it got an enum value that was outside the enum range. So I decided to go ahead with an UnknownExifTag enum value for values that were not in the enumeration. Oh, and I chose 0xFFFF instead of 0 because GpsVer has already used 0! You can still get the original Tag-Id by using the RawExifTagId property which returns an int.

The ExifReaderException class

/// <summary>
/// Represents an exception that is thrown whenever the ExifReader catches
/// any exception when applying a formatter or an extractor.
/// </summary>
[Serializable]
public class ExifReaderException : Exception
{
    /// <summary>
    /// Initializes a new instance of the ExifReaderException class.
    /// </summary>
    public ExifReaderException();

    /// <summary>
    /// Initializes a new instance of the ExifReaderException class 
    /// with the specific arguments
    /// </summary>
    /// <param name="innerException">The source exception</param>
    internal ExifReaderException(Exception innerException);

    /// <summary>
    /// Initializes a new instance of the ExifReaderException class 
    /// with the specific arguments
    /// </summary>
    /// <param name="message">The error message for the exception</param>
    /// <param name="innerException">The source exception</param>
    internal ExifReaderException(string message, Exception innerException);

    /// <summary>
    /// Initializes a new instance of the ExifReaderException class 
    /// with the specific arguments
    /// </summary>
    /// <param name="innerException">The source exception</param>
    /// <param name="propertyFormatter">The property formatter if any</param>
    internal ExifReaderException(Exception innerException, 
      IExifPropertyFormatter propertyFormatter);

    /// <summary>
    /// Initializes a new instance of the ExifReaderException class 
    /// with the specific arguments
    /// </summary>
    /// <param name="innerException">The source exception</param>
    /// <param name="undefinedExtractor">
    /// The undefined extractor if any</param>
    internal ExifReaderException(Exception innerException,  
      IExifValueUndefinedExtractor undefinedExtractor);

    /// <summary>
    /// Initializes a new instance of the ExifReaderException class 
    /// with the specific arguments
    /// </summary>
    /// <param name="innerException">The source exception</param>
    /// <param name="propertyFormatter">The property formatter if any</param>
    /// <param name="undefinedExtractor">The undefined extractor if any</param>
    internal ExifReaderException(Exception innerException, 
      IExifPropertyFormatter propertyFormatter, 
      IExifValueUndefinedExtractor undefinedExtractor);

    /// <summary>
    /// Initializes a new instance of the ExifReaderException class 
    /// with the specific arguments
    /// </summary>
    /// <param name="message">The error message for the exception</param>
    /// <param name="innerException">The source exception</param>
    /// <param name="propertyFormatter">The property formatter if any</param>
    /// <param name="undefinedExtractor">The undefined extractor if any</param>
    internal ExifReaderException(string message, 
      Exception innerException, 
      IExifPropertyFormatter propertyFormatter, 
      IExifValueUndefinedExtractor undefinedExtractor);

    /// <summary>
    /// Gets the property formatter used at the time of exception
    /// </summary>
    public IExifPropertyFormatter PropertyFormatter { get; private set; }

    /// <summary>
    /// Gets the undefined extractor used at the time of exception
    /// </summary>
    public IExifValueUndefinedExtractor UndefinedExtractor 
      { get; private set; }

    /// <summary>
    /// Sets info into the SerializationInfo object
    /// </summary>
    /// <param name="info">The serialized object data on the exception 
    /// being thrown</param>
    /// <param name="context">Contaisn context info</param>
    public override void GetObjectData(
      SerializationInfo info, StreamingContext context);
}

If you implement custom formatters or extractors, you should not throw an ExifReaderException, instead you should throw a standard exception or even a custom exception specific to your application. The ExifReader class will handle that exception and re-throw an ExifReaderException which will have your thrown exception as the InnerException, and hence the internal constructors (barring the default constructor which is left public for serialization).

Implementation Details

The source code is profusely commented and so anyone interested in getting a broad understanding of the code should probably browse through the source code. In this section I'll briefly talk about the basic design and also anything that I think will be interesting to a percentage of readers. As mentioned in the introduction, I use the System.Drawing Image class to get the Exif info out of a supported image file.

private void InitializeExifProperties()
{
    this.exifproperties = new List<ExifProperty>();

    foreach (var propertyItem in this.imageFile.PropertyItems)
    {
        this.exifproperties.Add(new ExifProperty(propertyItem, this));
    }
}

The InitializeExifProperties method creates an ExifProperty instance for every PropertyItem returned by the Image class. Before I go into what happens inside ExifProperty, I'd like to describe the IExifPropertyFormatter interface that is used to get a readable display-value for an Exif property.

/// <summary>
/// This interface defines how a property value is formatted for display
/// </summary>
public interface IExifPropertyFormatter
{
    /// <summary>
    /// Gets a display name for this property
    /// </summary>
    string DisplayName { get; }    
    
    /// <summary>
    /// Gets a formatted string for a given Exif value
    /// </summary>
    /// <param name="exifValue">The source Exif value</param>
    /// <returns>The formatted string</returns>
    string GetFormattedString(IExifValue exifValue);
}

ExifProperty has a field propertyFormatter of type IExifPropertyFormatter which is initialized in the constructor.

internal ExifProperty(PropertyItem propertyItem, ExifReader parentReader)
{
    this.parentReader = parentReader;
    this.propertyItem = propertyItem;
    this.isUnknown = !Enum.IsDefined(typeof(PropertyTagId), 
      this.RawExifTagId);

    var customFormatter = 
      this.parentReader.QueryForCustomPropertyFormatter(this.RawExifTagId);

    if (customFormatter == null)
    {
        this.propertyFormatter = 
          ExifPropertyFormatterProvider.GetExifPropertyFormatter(this.ExifTag);
    }
    else
    {
        this.propertyFormatter = customFormatter;
        this.hasCustomFormatter = true;
    }
}

The ExifProperty constructor calls QueryForCustomPropertyFormatter on the parent ExifReader class to see if there is an user specified property formatter available.

internal IExifPropertyFormatter QueryForCustomPropertyFormatter(
    int tagId)
{
    QueryPropertyFormatterEventArgs eventArgs = 
      new QueryPropertyFormatterEventArgs(tagId);
    this.FireQueryPropertyFormatter(eventArgs);
    return eventArgs.PropertyFormatter;
}

If there is no custom formatter provided, then a property formatter is obtained via the ExifPropertyFormatterProvider class.

Specifying property formatters via a custom enum attribute

ExifPropertyFormatterProvider is a class that returns an IExifPropertyFormatter for a given Exif tag. It looks for a custom attribute in the PropertyTagId enumeration to figure out what property formatter needs to be used. Here're a couple of examples of how an enum value might specify a property formatter.

[ExifPropertyFormatter(typeof(ExifExposureTimePropertyFormatter))]
ExifExposureTime = 0x829A,

[ExifPropertyFormatter(typeof(ExifFNumberPropertyFormatter), 
          ConstructorNeedsPropertyTag = true)]
[EnumDisplayName("F-Stop")]
ExifFNumber = 0x829D,

ExifPropertyFormatter is a custom attribute that can be applied to an enum.

/// <summary>
/// An attribute used to specify an IExifPropertyFormatter for Exif Tag Ids 
/// </summary>
[AttributeUsage(AttributeTargets.Field)]
internal class ExifPropertyFormatterAttribute : Attribute
{
    /// <summary>
    /// The IExifPropertyFormatter object
    /// </summary>
    private IExifPropertyFormatter exifPropertyFormatter;

    /// <summary>
    /// The type of the IExifPropertyFormatter
    /// </summary>
    private Type exifPropertyFormatterType;

    /// <summary>
    /// Initializes a new instance of the ExifPropertyFormatterAttribute class
    /// </summary>
    /// <param name="exifPropertyFormatterType">
    /// The type of the IExifPropertyFormatter</param>
    public ExifPropertyFormatterAttribute(Type exifPropertyFormatterType)
    {
        this.exifPropertyFormatterType = exifPropertyFormatterType;
    }

    /// <summary>
    /// Gets or sets a value indicating whether the constructor 
    /// for the property formatter
    /// needs to be passed the property tag as an argument. 
    /// </summary>
    public bool ConstructorNeedsPropertyTag { get; set; }

    /// <summary>
    /// Gets the IExifPropertyFormatter
    /// </summary>
    /// <param name="args">Optional arguments</param>
    /// <returns>The IExifPropertyFormatter</returns>
    public IExifPropertyFormatter GetExifPropertyFormatter(
        params object[] args)
    {
            return this.exifPropertyFormatter ??
                (this.exifPropertyFormatter = 
                  Activator.CreateInstance(
                  this.exifPropertyFormatterType, 
                  args) as IExifPropertyFormatter);
    }
}

And here's how the ExifPropertyFormatterProvider class uses this attribute to return the appropriate property formatter.

/// <summary>
/// This class provides appropriate IExifPropertyFormatter 
/// objects for Exif property values
/// </summary>
public static class ExifPropertyFormatterProvider
{
    /// <summary>
    /// Gets an IExifPropertyFormatter for the specific tagId
    /// </summary>
    /// <param name="tagId">The Exif Tag Id</param>
    /// <returns>An IExifPropertyFormatter</returns>
    internal static IExifPropertyFormatter GetExifPropertyFormatter(
        PropertyTagId tagId)
    {
        ExifPropertyFormatterAttribute attribute = 
          CachedAttributeExtractor<PropertyTagId, 
            ExifPropertyFormatterAttribute>.Instance.GetAttributeForField(
              tagId.ToString());

        if (attribute != null)
        {
            return attribute.ConstructorNeedsPropertyTag ? 
              attribute.GetExifPropertyFormatter(tagId) : 
              attribute.GetExifPropertyFormatter();
        }

        return new SimpleExifPropertyFormatter(tagId);
    }
}

If the attribute is found, the attribute's associated property formatter is returned. If there is no match, then a basic formatter is returned.

The CachedAttributeExtractor utility class

Notice how I've used the CachedAttributeExtractor utility class to extract the custom attribute. It's a handy little class that not only makes it easy to extract attributes but also caches the attributes for later access.

/// <summary>
/// A generic class used to retrieve an attribute from a type, 
/// and cache the extracted values for future access.
/// </summary>
/// <typeparam name="T">The type to search on</typeparam>
/// <typeparam name="A">The attribute type to extract</typeparam>
internal class CachedAttributeExtractor<T, A> where A : Attribute
{
    /// <summary>
    /// The singleton instance
    /// </summary>
    private static CachedAttributeExtractor<T, A> instance 
      = new CachedAttributeExtractor<T, A>();

    /// <summary>
    /// The map of fields to attributes
    /// </summary>
    private Dictionary<string, A> fieldAttributeMap 
      = new Dictionary<string, A>();

    /// <summary>
    /// Prevents a default instance of the CachedAttributeExtractor 
    /// class from being created.
    /// </summary>
    private CachedAttributeExtractor()
    {
    }

    /// <summary>
    /// Gets the singleton instance
    /// </summary>
    internal static CachedAttributeExtractor<T, A> Instance
    {
        get { return CachedAttributeExtractor<T, A>.instance; }
    }

    /// <summary>
    /// Gets the attribute for the field
    /// </summary>
    /// <param name="field">Name of the field</param>
    /// <returns>The attribute on the field or null</returns>
    public A GetAttributeForField(string field)
    {
        A attribute;

        if (!this.fieldAttributeMap.TryGetValue(field, out attribute))
        {
            if (this.TryExtractAttributeFromField(field, out attribute))
            {
                this.fieldAttributeMap[field] = attribute;
            }
            else
            {
                attribute = null;
            }
        }

        return attribute;
    }

    /// <summary>
    /// Get the attribute for the field 
    /// </summary>
    /// <param name="field">Name of the field</param>
    /// <param name="attribute">The attribute</param>
    /// <returns>Returns true of the attribute was found</returns>
    private bool TryExtractAttributeFromField(
        string field, out A attribute)
    {
        var fieldInfo = typeof(T).GetField(field);
        attribute = null;

        if (fieldInfo != null)
        {
            A[] attributes = fieldInfo.GetCustomAttributes(
                typeof(A), false) as A[];
            if (attributes.Length > 0)
            {
                attribute = attributes[0];
            }
        }

        return attribute != null;
    }
}

Creating the Exif values

Before going into how the various property formatters are implemented, I'll take you through how the Exif values themselves are created. There's an InitializeExifValue method that's called to create the IExifValue object for an ExifProperty instance.

private IExifValue InitializeExifValue()
{
    try
    {
        var customExtractor = 
          this.parentReader.QueryForCustomUndefinedExtractor(
            this.RawExifTagId);
        if (customExtractor != null)
        {
            return this.exifValue = customExtractor.GetExifValue(
              this.propertyItem.Value, this.propertyItem.Len);
        } 

        return this.exifValue = 
          this.ExifDatatype == PropertyTagType.Undefined ?
            ExifValueCreator.CreateUndefined(
              this.ExifTag, 
              this.propertyItem.Value, 
              this.propertyItem.Len) :
            ExifValueCreator.Create(
              this.ExifDatatype, 
              this.propertyItem.Value, 
              this.propertyItem.Len);
    }
    catch (ExifReaderException ex)
    {
        throw new InvalidOperationException(
"An ExifReaderException was caught. See InnerException for more details",
          ex);
    }
    catch (Exception ex)
    {
        throw new InvalidOperationException(
"An ExifReaderException was caught. See InnerException for more details",
            new ExifReaderException(ex, this.propertyFormatter, null));
    }
}

Just as the code first checked for a custom property formatter in the constructor, here it checks for a custom extractor by calling QueryForCustomUndefinedExtractor on the parent ExifReader.

internal IExifValueUndefinedExtractor QueryForCustomUndefinedExtractor(
    int tagId)
{
    QueryUndefinedExtractorEventArgs eventArgs = 
        new QueryUndefinedExtractorEventArgs(tagId);
    this.FireQueryUndefinedExtractor(eventArgs);
    return eventArgs.UndefinedExtractor;
}

If there's no custom extractor provided, ExifValueCreator.CreateUndefined is called for undefined data types, and ExifValueCreator.Create is called for well-known data types. You should also note how the ExifReaderException is caught and re-thrown in an InvalidOperationException. This is because InitializeExifValue is called by the ExifProperty.ExifValue property (shown below) and properties are not expected to throw any arbitrary exception. Both WinForms and WPF databinding can correctly handle exceptions of type InvalidOperationException, hence the catch and re-throw.

public IExifValue ExifValue
{
    get
    {
        return this.exifValue ?? this.InitializeExifValue();
    }
}

The ExifValueCreator class

The ExifValueCreator is a factory class for creating different types of ExifValue objects. It declares a private delegate with the following signature.

/// <summary>
/// Delegate that creates the appropriate Exif value of a specific type
/// </summary>
/// <param name="value">Array of bytes representing the value or values
/// </param>
/// <param name="length">Number of values or length of an ASCII string value
/// </param>
/// <returns>The Exif value or values</returns>
private delegate IExifValue CreateExifValueDelegate(
    byte[] value, int length);

It also has a built-in map of Exif data types to their corresponding creation methods.

/// <summary>
/// Delegate map between Exif tag types and associated creation methods
/// </summary>
private static Dictionary<PropertyTagType, CreateExifValueDelegate> 
  createExifValueDelegateMap = 
    new Dictionary<PropertyTagType, CreateExifValueDelegate>()
{
    { PropertyTagType.ASCII, CreateExifValueForASCIIData },
    { PropertyTagType.Byte, CreateExifValueForByteData },
    { PropertyTagType.Short, CreateExifValueForShortData },
    { PropertyTagType.Long, CreateExifValueForLongData },            
    { PropertyTagType.SLONG, CreateExifValueForSLongData },            
    { PropertyTagType.Rational, CreateExifValueForRationalData },            
    { PropertyTagType.SRational, CreateExifValueForSRationalData }
};

The Create method gets the appropriate method based on the passed in Exif data type and invokes the delegate and returns its return value.

/// <summary>
/// Creates an ExifValue for a specific type
/// </summary>
/// <param name="type">The property data type</param>
/// <param name="value">An array of bytes representing the value or 
/// values</param>
/// <param name="length">A length parameter specifying the number of 
/// values or the length of a string for ASCII string data</param>
/// <returns>An appropriate IExifValue object</returns>
internal static IExifValue Create(
    PropertyTagType type, byte[] value, int length)
{
    try
    {
        CreateExifValueDelegate createExifValueDelegate;
        if (createExifValueDelegateMap.TryGetValue(
            type, out createExifValueDelegate))
        {
            return createExifValueDelegate(value, length);
        }

        return new ExifValue<string>(new[] { type.ToString() });
    }
    catch (Exception ex)
    {
        throw new ExifReaderException(ex);
    }
}

Data types used by the ExifReader

Most of the Exif data types that are defined in the PropertyTagType enum have corresponding matches in the .NET type system. For example, the ASCII Exif type would be a System.String, a Long would be a 32 bit unsigned integer (a uint in C#), and an SLong would be a 32 bit signed integer (an int in C#). But there are also two types that don't have direct .NET equivalents, Rational and SRational, and I wrote a simple Rational32 struct that represents either of those types. I didn't want separate structs for the signed and unsigned versions even though that's what's done in the .NET framework (examples : UInt32/Int32, UInt64/Int64). To facilitate that, I also wrote a simple struct called CommonInt32 that can efficiently represent either an int or an uint in a mostly transparent fashion so the caller need not unduly worry about what type is being accessed.

/// <summary>
/// A struct that can efficiently represent either an int or an uint
/// </summary>
[StructLayout(LayoutKind.Explicit)]
public struct CommonInt32 : IEquatable<CommonInt32>
{
    /// <summary>
    /// Integer value
    /// </summary>
    [FieldOffset(0)]
    private int integer;

    /// <summary>
    /// Unsigned integer value
    /// </summary>
    [FieldOffset(0)]
    private uint uinteger;

    /// <summary>
    /// True if this is a signed value
    /// </summary>
    [FieldOffset(4)]
    private bool isSigned;

    /// <summary>
    /// Initializes a new instance of the CommonInt32 struct
    /// </summary>
    /// <param name="integer">The int value</param>
    public CommonInt32(int integer)
        : this()
    {
        this.integer = integer;
        this.isSigned = true;
    }

    /// <summary>
    /// Initializes a new instance of the CommonInt32 struct
    /// </summary>
    /// <param name="uinteger">The uint value</param>
    public CommonInt32(uint uinteger)
        : this()
    {
        this.uinteger = uinteger;
        this.isSigned = false;
    }

    /// <summary>
    /// Gets a value indicating whether the value of 
    /// this struct is signed or not
    /// </summary>
    public bool IsSigned
    {
        get
        {
            return this.isSigned;
        }
    }

    /// <summary>
    /// Explicit operator overload to int
    /// </summary>
    /// <param name="commonInt">Source object to convert</param>
    /// <returns>The int value</returns>
    public static explicit operator int(CommonInt32 commonInt)
    {
        return commonInt.integer;
    }

    /// <summary>
    /// Explicit operator overload to uint
    /// </summary>
    /// <param name="commonInt">Source object to convert</param>
    /// <returns>The uint value</returns>
    public static explicit operator uint(CommonInt32 commonInt)
    {
        return commonInt.uinteger;
    }

    /// <summary>
    /// Override for Equals
    /// </summary>
    /// <param name="obj">Object to check equality with</param>
    /// <returns>True if they are equal</returns>
    public override bool Equals(object obj)
    {
        return obj is CommonInt32 && this.Equals((CommonInt32)obj);
    }

    /// <summary>
    /// Tests if this instance is equal to another
    /// </summary>
    /// <param name="other">The other instance</param>
    /// <returns>True if they are equal</returns>
    public bool Equals(CommonInt32 other)
    {
        if (this.isSigned != other.isSigned)
        {
            return false;
        }

        return this.isSigned ?
            this.integer.Equals(other.integer) :
            this.uinteger.Equals(other.uinteger);
    }

    /// <summary>
    /// Override for GetHashCode
    /// </summary>
    /// <returns>Returns a hash code for this object</returns>
    public override int GetHashCode()
    {
        return this.isSigned ? 
          this.integer.GetHashCode() : this.uinteger.GetHashCode();
    }
}

By using a StructLayout of LayoutKind.Explicit and by using FieldOffset(0) for both the int and the uint field, the struct will not need any more space than it needs. This is a gratuitous optimization and was not originally done for optimization reasons, but because I was attempting an even more transparent struct to map between int and uint, but eventually I changed other areas of my code and thus did not need that anymore. I decided to keep the overlapping FieldOffset scheme in since I had already written the code. The Rational32 struct uses CommonInt32 fields to represent either a signed number or an unsigned number, and thereby avoids having two separate types for this.

/// <summary>
/// Struct that represents a rational number
/// </summary>
public struct Rational32 
  : IComparable, IComparable<Rational32>, IEquatable<Rational32>
{
    /// <summary>
    /// Separator character for the string representation
    /// </summary>
    private const char SEPARATOR = '/';

    /// <summary>
    /// The numerator
    /// </summary>
    private CommonInt32 numerator;
    
    /// <summary>
    /// The denominator
    /// </summary>
    private CommonInt32 denominator;        

    /// <summary>
    /// Initializes a new instance of the Rational32 struct for signed use
    /// </summary>
    /// <param name="numerator">The numerator</param>
    /// <param name="denominator">The denominator</param>
    public Rational32(int numerator, int denominator)
        : this()
    {
        int gcd = Rational32.EuclidGCD(numerator, denominator);

        this.numerator = new CommonInt32(numerator / gcd);
        this.denominator = new CommonInt32(denominator / gcd);
    }

    /// <summary>
    /// Initializes a new instance of the Rational32 struct for unsigned use
    /// </summary>
    /// <param name="numerator">The numerator</param>
    /// <param name="denominator">The denominator</param>
    public Rational32(uint numerator, uint denominator)
        : this()
    {
        uint gcd = Rational32.EuclidGCD(numerator, denominator);

        this.numerator = new CommonInt32(numerator / gcd);
        this.denominator = new CommonInt32(denominator / gcd);
    }

    /// <summary>
    /// Gets the numerator
    /// </summary>
    public CommonInt32 Numerator
    {
        get { return this.numerator; }
    }

    /// <summary>
    /// Gets the denominator
    /// </summary>
    public CommonInt32 Denominator
    {
        get { return this.denominator; }
    }

    /// <summary>
    /// Explicit conversion operator to double
    /// </summary>
    /// <param name="rational">The source object</param>
    /// <returns>A double value representing the source object</returns>
    public static explicit operator double(Rational32 rational)
    {
        return rational.denominator.IsSigned ?
            (int)rational.denominator == 0 ? 
              0.0 : 
                (double)(int)rational.numerator / 
                (double)(int)rational.denominator :
            (uint)rational.denominator == 0 ? 
              0.0 : 
                (double)(uint)rational.numerator / 
                (double)(uint)rational.denominator;
    }

    /// <summary>
    /// Operator overload for GreaterThan
    /// </summary>
    /// <param name="x">Left value</param>
    /// <param name="y">Right value</param>
    /// <returns>True if the left instance is greater than the right 
    /// instance</returns>
    public static bool operator >(Rational32 x, Rational32 y)
    {
        return (double)x > (double)y;
    }

    /// <summary>
    /// Operator overload for GreaterThanOrEqual
    /// </summary>
    /// <param name="x">Left value</param>
    /// <param name="y">Right value</param>
    /// <returns>True if the left instance is greater than or equal to 
    /// the right instance</returns>
    public static bool operator >=(Rational32 x, Rational32 y)
    {
        return (double)x >= (double)y;
    }

    /// <summary>
    /// Operator overload for LesserThan
    /// </summary>
    /// <param name="x">Left value</param>
    /// <param name="y">Right value</param>
    /// <returns>True if the left instance is lesser than the right 
    /// instance</returns>
    public static bool operator <(Rational32 x, Rational32 y)
    {
        return (double)x < (double)y;
    }

    /// <summary>
    /// Operator overload for LesserThanOrEqual
    /// </summary>
    /// <param name="x">Left value</param>
    /// <param name="y">Right value</param>
    /// <returns>True if the left instance is lesser than or equal to 
    /// the right instance</returns>
    public static bool operator <=(Rational32 x, Rational32 y)
    {
        return (double)x <= (double)y;
    }

    /// <summary>
    /// Override for ToString
    /// </summary>
    /// <returns>The string representation</returns>
    public override string ToString()
    {
        return this.denominator.IsSigned ?
            String.Format("{0} {1} {2}", (int)this.numerator, 
              Rational32.SEPARATOR, (int)this.denominator) :
            String.Format("{0} {1} {2}", (uint)this.numerator, 
              Rational32.SEPARATOR, (uint)this.denominator);
    }

    /// <summary>
    /// Override for Equals
    /// </summary>
    /// <param name="obj">Object to check equality with</param>
    /// <returns>True if they are equal</returns>
    public override bool Equals(object obj)
    {
        return obj is Rational32 && this.Equals((Rational32)obj);
    }

    /// <summary>
    /// Tests if this instance is equal to another
    /// </summary>
    /// <param name="other">The other instance</param>
    /// <returns>True if they are equal</returns>
    public bool Equals(Rational32 other)
    {
        return this.numerator.Equals(other.numerator) && 
          this.denominator.Equals(other.denominator);
    }

    /// <summary>
    /// Override for GetHashCode
    /// </summary>
    /// <returns>Returns a hash code for this object</returns>
    public override int GetHashCode()
    {
        int primeSeed = 29;
        return unchecked((this.numerator.GetHashCode() + primeSeed) * 
          this.denominator.GetHashCode());
    }

    /// <summary>
    /// Compares this instance with an object
    /// </summary>
    /// <param name="obj">An object to compare with this instance</param>
    /// <returns>Zero of equal, 1 if greater than, and -1 if less than 
    /// the compared to object</returns>
    public int CompareTo(object obj)
    {
        if (obj == null)
        {
            return 1;
        }

        if (!(obj is Rational32))
        {
            throw new ArgumentException("Rational32 expected");
        }

        return this.CompareTo((Rational32)obj);
    }

    /// <summary>
    /// Compares this instance with another
    /// </summary>
    /// <param name="other">A Rational32 object to compare with this 
    /// instance</param>
    /// <returns>Zero of equal, 1 if greater than, and -1 if less than 
    /// the compared to object</returns>
    public int CompareTo(Rational32 other)
    {
        if (this.Equals(other))
        {
            return 0;
        }

        return ((double)this).CompareTo((double)other);
    }

    /// <summary>
    /// Calculates the GCD for two signed ints
    /// </summary>
    /// <param name="x">First signed int</param>
    /// <param name="y">Second signed int</param>
    /// <returns>The GCD for the two numbers</returns>
    private static int EuclidGCD(int x, int y)
    {
        return y == 0 ? x : EuclidGCD(y, x % y);
    }

    /// <summary>
    /// Calculates the GCD for two unsigned ints
    /// </summary>
    /// <param name="x">First unsigned int</param>
    /// <param name="y">Second unsigned int</param>
    /// <returns>The GCD for the two numbers</returns>
    private static uint EuclidGCD(uint x, uint y)
    {
        return y == 0 ? x : EuclidGCD(y, x % y);
    }
}

Creation methods in ExifValueCreator

I have a couple of generic methods which create an IExifValue from a given array of bytes.

/// <summary>
/// Generic creation method
/// </summary>
/// <typeparam name="T">The data type of the value data</typeparam>
/// <param name="value">Bytes representing the data</param>
/// <param name="length">Number of bytes</param>
/// <param name="converterFunction">Function that converts from bytes 
/// to a specific data type</param>
/// <returns>Exif value representing the generic data type</returns>
private static IExifValue CreateExifValueForGenericData<T>(
  byte[] value, int length, 
  Func<byte[], int, T> converterFunction) where T : struct
{
    int size = Marshal.SizeOf(typeof(T));
    return CreateExifValueForGenericData(
      value, length, size, converterFunction);
}
/// <summary>
/// Generic creation method
/// </summary>
/// <typeparam name="T">The data type of the value data</typeparam>
/// <param name="value">Bytes representing the data</param>
/// <param name="length">Number of bytes</param>
/// <param name="dataValueSize">Size of each data value</param>
/// <param name="converterFunction">Function that converts from bytes 
/// to a specific data type</param>
/// <returns>Exif value representing the generic data type</returns>
private static IExifValue CreateExifValueForGenericData<T>(
  byte[] value, int length, int dataValueSize, 
  Func<byte[], int, T> converterFunction) where T : struct
{
    T[] data = new T[length / dataValueSize];

    for (int i = 0, pos = 0; i < length / dataValueSize; 
        i++, pos += dataValueSize)
    {
        data[i] = converterFunction(value, pos);
    }

    return new ExifValue<T>(data);
}  

The individual creation methods will merely call one of the above two methods. Here are a couple of examples.

/// <summary>
/// Creation method for SRational values
/// </summary>
/// <param name="value">Bytes representing the SRational data</param>
/// <param name="length">Number of bytes</param>
/// <returns>Exif value representing the Rational data</returns>
private static IExifValue CreateExifValueForSRationalData(
    byte[] value, int length)
{
    return CreateExifValueForGenericData(
        value, 
        length,
        sizeof(int) * 2,
        (bytes, pos) => new Rational32(
            System.BitConverter.ToInt32(bytes, pos), 
            System.BitConverter.ToInt32(bytes, pos + sizeof(int))));
}

/// <summary>
/// Creation method for long values
/// </summary>
/// <param name="value">Bytes representing the long data</param>
/// <param name="length">Number of bytes</param>
/// <returns>Exif value representing the long data</returns>
private static IExifValue CreateExifValueForLongData(
    byte[] value, int length)
{
    return CreateExifValueForGenericData(value, length, 
      (bytes, pos) => System.BitConverter.ToUInt32(bytes, pos));
}        

ExifValue<T> is a generic class that can be used to instantiate an IExifValue of a specific type. If you write custom Exif tag handlers you can use this class instead of implementing an IExifValue class from scratch.

/// <summary>
/// This class represents an Exif property value (or values)
/// </summary>
/// <typeparam name="T">The type of the Exif property value</typeparam>
public class ExifValue<T> : IExifValue
{
    /// <summary>
    /// Array of values
    /// </summary>
    private T[] values;

    /// <summary>
    /// Initializes a new instance of the ExifValue class.
    /// </summary>
    /// <param name="values">Array of Exif values</param>
    public ExifValue(T[] values)
    {
        this.values = values;
    }

    /// <summary>
    /// Gets the type of the Exif property value or values
    /// </summary>
    public Type ValueType
    {
        get { return typeof(T); }
    }

    /// <summary>
    /// Gets the number of values
    /// </summary>
    public int Count
    {
        get { return this.values.Length; }
    }

    /// <summary>
    /// Gets a type-unsafe collection of values of a 
    /// specific Exif tag data type
    /// </summary>
    public IEnumerable Values
    {
        get { return this.values.AsEnumerable(); }
    }
}

Built-in extractors for undefined types

The CreateUndefined method is used to create an IExifValue for an undefined data type.

/// <summary>
/// Creates an ExifValue for an undefined value type
/// </summary>
/// <param name="tagId">The tag Id whose value needs to 
/// be extracted</param>
/// <param name="value">An array of bytes representing the value or 
/// values</param>
/// <param name="length">The number of bytes</param>
/// <returns>An appropriate IExifValue object</returns>
internal static IExifValue CreateUndefined(
    PropertyTagId tagId, byte[] value, int length)
{
    var extractor = 
      ExifValueUndefinedExtractorProvider.GetExifValueUndefinedExtractor(
        tagId);

    try
    {
        return extractor.GetExifValue(value, length);
    }
    catch (Exception ex)
    {
        throw new ExifReaderException(ex, extractor);
    }
}

ExifValueUndefinedExtractorProvider is a class that gets an extractor object for a given tag Id. It does this by looking at the PropertyTagId enum for ExifValueUndefinedExtractor attributes. This is similar to how ExifPropertyFormatterProvider looks for ExifPropertyFormatter attributes.

[ExifValueUndefinedExtractor(typeof(ExifFileSourceUndefinedExtractor))]
[EnumDisplayName("File Source")]
ExifFileSource = 0xA300,

[ExifValueUndefinedExtractor(typeof(ExifSceneTypeUndefinedExtractor))]
[EnumDisplayName("Scene Type")]
ExifSceneType = 0xA301,

Here is how the ExifValueUndefinedExtractorAttribute class is defined.

/// <summary>
/// An attribute used to specify an IExifValueUndefinedExtractor for 
/// Exif Tags with undefined data value types
/// </summary>
[AttributeUsage(AttributeTargets.Field)]
internal class ExifValueUndefinedExtractorAttribute : Attribute
{
    /// <summary>
    /// The IExifValueUndefinedExtractor object
    /// </summary>
    private IExifValueUndefinedExtractor undefinedExtractor;

    /// <summary>
    /// The type of the IExifValueUndefinedExtractor
    /// </summary>
    private Type undefinedExtractorType;

    /// <summary>
    /// Initializes a new instance of the 
    /// ExifValueUndefinedExtractorAttribute class
    /// </summary>
    /// <param name="undefinedExtractorType">
    /// The type of the IExifValueUndefinedExtractor</param>
    public ExifValueUndefinedExtractorAttribute(Type undefinedExtractorType)
    {
        this.undefinedExtractorType = undefinedExtractorType;
    }

    /// <summary>
    /// Gets the IExifValueUndefinedExtractor
    /// </summary>
    /// <returns>The IExifValueUndefinedExtractor</returns>
    public IExifValueUndefinedExtractor GetUndefinedExtractor()
    {
        return this.undefinedExtractor ??
            (this.undefinedExtractor = 
              Activator.CreateInstance(this.undefinedExtractorType) 
              as IExifValueUndefinedExtractor);
    }
}

And here's the code for ExifValueUndefinedExtractorProvider, which uses the CachedAttributeExtractor utility class just as the ExifPropertyFormatterProvider did.

/// <summary>
/// This class provides appropriate IExifValueUndefinedExtractor objects
///  for Exif property values with undefined data
/// </summary>
public static class ExifValueUndefinedExtractorProvider
{
    /// <summary>
    /// Gets an IExifValueUndefinedExtractor for the specific tagId
    /// </summary>
    /// <param name="tagId">The Exif Tag Id</param>
    /// <returns>An IExifValueUndefinedExtractor</returns>
    internal static IExifValueUndefinedExtractor 
      GetExifValueUndefinedExtractor(PropertyTagId tagId)
    {
        ExifValueUndefinedExtractorAttribute attribute = 
          CachedAttributeExtractor<PropertyTagId, 
            ExifValueUndefinedExtractorAttribute>.Instance.GetAttributeForField(
            tagId.ToString());

        if (attribute != null)
        {
            return attribute.GetUndefinedExtractor();
        }

        return new SimpleUndefinedExtractor();
    }
}

Here're a couple of undefined property extractors (please see the project source for other examples).

/// <summary>
/// A class that extracts a value for the Exif File Source property
/// </summary>
internal class ExifFileSourceUndefinedExtractor : IExifValueUndefinedExtractor
{
    /// <summary>
    /// Gets the Exif Value
    /// </summary>
    /// <param name="value">Array of bytes representing 
    /// the value or values</param>
    /// <param name="length">Number of bytes</param>
    /// <returns>The Exif Value</returns>
    public IExifValue GetExifValue(byte[] value, int length)
    {
        string fileSource = value.FirstOrDefault() == 3 ? "DSC" : "Reserved";
        return new ExifValue<string>(new[] { fileSource });
    }
}
/// <summary>
/// Does not attempt to translate the bytes and merely returns 
/// a string representation
/// </summary>
internal class SimpleUndefinedExtractor : IExifValueUndefinedExtractor
{
    /// <summary>
    /// Gets the Exif Value
    /// </summary>
    /// <param name="value">Array of bytes representing 
    /// the value or values</param>
    /// <param name="length">Number of bytes</param>
    /// <returns>The Exif Value</returns>
    public IExifValue GetExifValue(byte[] value, int length)
    {
        string bytesString = String.Join(" ", 
          value.Select(b => b.ToString("X2")));
        return new ExifValue<string>(new[] { bytesString });
    }
}

The SimpleUndefinedExtractor class above is the default handler for undefined property tags and gets used if there is no built-in extractor available and the user has not provided a custom extractor either.

Built in formatters

The ExifReader comes with over a couple of dozen property formatters which cover the most commonly accessed Exif tags. As I mentioned in the introduction, if you encounter a common Exif tag that is not handled by the ExifReader, I'll be glad to add support for that if you can send me a couple of test images with that particular Exif tag. Alternatively you can write a custom handler for it. I will list a few of the built-in formatters just so you get an idea, and people who want to see them all can look at the project source code.

/// <summary>
/// An IExifPropertyFormatter specific to the ISO property
/// </summary>
internal class ExifISOSpeedPropertyFormatter : IExifPropertyFormatter
{
    /// <summary>
    /// Gets a display name for this property
    /// </summary>
    public string DisplayName
    {
        get
        {
            return "ISO Speed";
        }
    } 

    /// <summary>
    /// Gets a formatted string for a given Exif value
    /// </summary>
    /// <param name="exifValue">The source Exif value</param>
    /// <returns>The formatted string</returns>
    public string GetFormattedString(IExifValue exifValue)
    {
        var values = exifValue.Values.Cast<ushort>();
        return values.Count() == 0 ? 
          String.Empty : String.Format("ISO-{0}", values.First());
    }
}

This is a fairly simple formatter. The ISO speed is represented by a single unsigned short value. So all we do is extract that value and format it to a standard ISO display string.

/// <summary>
/// An IExifPropertyFormatter specific to the Gps 
/// Latitude and Longitude properties
/// </summary>
internal class GpsLatitudeLongitudePropertyFormatter 
    : SimpleExifPropertyFormatter
{
    /// <summary>
    /// Initializes a new instance of the 
    /// GpsLatitudeLongitudePropertyFormatter class.
    /// </summary>
    /// <param name="tagId">The associated PropertyTagId</param>
    public GpsLatitudeLongitudePropertyFormatter(PropertyTagId tagId)
        : base(tagId)
    {            
    }

    /// <summary>
    /// Gets a formatted string for a given Exif value
    /// </summary>
    /// <param name="exifValue">The source Exif value</param>
    /// <returns>The formatted string</returns>
    public override string GetFormattedString(IExifValue exifValue)
    {
        var values = exifValue.Values.Cast<Rational32>();
        if (values.Count() != 3)
        {
            return String.Empty;
        }

        return String.Format("{0}; {1}; {2}", 
          (double)values.ElementAt(0), 
          (double)values.ElementAt(1), 
          (double)values.ElementAt(2));
    }
}

This formatter is used by both the GpsLatitude and the GpsLongitude Exif tags. Here there are three Rational values, and you can see how the sign-transparency of the Rational32 class means we don't need to particularly check for a signed versus unsigned number.

/// <summary>
/// An IExifPropertyFormatter specific to the Exif shutter-speed property
/// </summary>
internal class ExifShutterSpeedPropertyFormatter : IExifPropertyFormatter
{
    . . .

    /// <summary>
    /// Gets a formatted string for a given Exif value
    /// </summary>
    /// <param name="exifValue">The source Exif value</param>
    /// <returns>The formatted string</returns>
    public string GetFormattedString(IExifValue exifValue)
    {
        var values = exifValue.Values.Cast<Rational32>();

        if (values.Count() == 0)
        {
            return String.Empty;
        }

        double apexValue = (double)values.First();
        double shutterSpeed = 1 / Math.Pow(2, apexValue);

        return shutterSpeed > 1 ?
            String.Format("{0} sec.", (int)Math.Round(shutterSpeed)) :
            String.Format("{0}/{1} sec.", 1, (int)Math.Round(1 / shutterSpeed));            
    }
}

This one's similar to the ISO-speed formatter except it's a rational data type and also needs a little math and some little formatting work applied. As I was implementing these formatters I quickly found that a vast majority of them required mapping from a numeric data value to a string representation. To facilitate that, I wrote a base class that will handle the mapping, so that implementing classes need not duplicate a lot of the code lookup logic.

/// <summary>
/// An IExifPropertyFormatter base implementation for formatters that 
/// use a basic dictionary to map values to names
/// </summary>
/// <typeparam name="VTYPE">The type of the value that maps to the 
/// string</typeparam>
internal abstract class GenericDictionaryPropertyFormatter<VTYPE> 
    : IExifPropertyFormatter
{
    /// <summary>
    /// Gets a display name for this property
    /// </summary>
    public abstract string DisplayName { get; }

    /// <summary>
    /// Gets a formatted string for a given Exif value
    /// </summary>
    /// <param name="exifValue">The source Exif value</param>
    /// <returns>The formatted string</returns>
    public string GetFormattedString(IExifValue exifValue)
    {
        var values = exifValue.Values.Cast<VTYPE>();

        return this.GetStringValueInternal(values.FirstOrDefault());
    }

    /// <summary>
    /// Gets a dictionary that maps values to named strings
    /// </summary>
    /// <returns>The mapping dictionary</returns>
    protected abstract Dictionary<VTYPE, string> GetNameMap();

    /// <summary>
    /// Gets the reserved string for values not in the dictionary
    /// </summary>
    /// <returns>The reserved string</returns>
    protected virtual string GetReservedValue()
    {
        return "Reserved";
    }

    /// <summary>
    /// Returns an Exif Light Source from a VTYPE value
    /// </summary>
    /// <param name="value">The VTYPE value</param>
    /// <returns>The string value</returns>
    private string GetStringValueInternal(VTYPE value)
    {
        string stringValue;

        if (!this.GetNameMap().TryGetValue(value, out stringValue))
        {
            stringValue = this.GetReservedValue();
        }

        return stringValue;
    }
}

Here's an example of how a formatter class derives from the above class.

/// <summary>
/// An IExifPropertyFormatter specific to the Metering Mode property
/// </summary>
internal class ExifMeteringModePropertyFormatter 
    : GenericDictionaryPropertyFormatter<ushort>
{
    /// <summary>
    /// Map of metering modes to their unsigned short representations
    /// </summary>
    private Dictionary<ushort, string> meteringModeMap 
      = new Dictionary<ushort, string>()
    {
        { 0, "Unknown" },
        { 1, "Average" },
        { 2, "Center-Weighted" },
        { 3, "Spot" },
        { 4, "Multi-Spot" },
        { 5, "Pattern" },
        { 6, "Partial" },
        { 255, "Other" }
    };

    /// <summary>
    /// Gets a display name for this property
    /// </summary>
    public override string DisplayName
    {
        get { return "Metering Mode"; }
    }

    /// <summary>
    /// Gets a dictionary that maps values to named strings
    /// </summary>
    /// <returns>The mapping dictionary</returns>
    protected override Dictionary<ushort, string> GetNameMap()
    {
        return this.meteringModeMap;
    }
}

Support for the Windows Forms property-grid

The reason I added this support was because of my presumption that there will be quite a few scenarios where a WinForms app merely wants to show all the Exif properties in a form. And the quickest way to do it would be with a property grid control. Supporting the PropertyGrid was fairly straightforward. The ExifReaderTypeDescriptionProvider class acts as a TypeDescriptionProvider for the ExifReader class.

/// <summary>
/// Implements a TypeDescriptionProvider for ExifReader
/// </summary>
internal class ExifReaderTypeDescriptionProvider : TypeDescriptionProvider
{
    /// <summary>
    /// The default TypeDescriptionProvider to use
    /// </summary>
    private static TypeDescriptionProvider defaultTypeProvider = 
      TypeDescriptor.GetProvider(typeof(ExifReader));
    
    . . .

    /// <summary>
    /// Gets a custom type descriptor for the given type and object.
    /// </summary>
    /// <param name="objectType">The type of object for which to retrieve 
    /// the type descriptor</param>
    /// <param name="instance">An instance of the type.</param>
    /// <returns>Returns a custom type descriptor</returns>
    public override ICustomTypeDescriptor GetTypeDescriptor(
        Type objectType, object instance)
    {
        ICustomTypeDescriptor defaultDescriptor = 
          base.GetTypeDescriptor(objectType, instance);

        return instance == null ? defaultDescriptor : 
          new ExifReaderCustomTypeDescriptor(defaultDescriptor, instance);
    }
}

The ExifReaderCustomTypeDescriptor instance returned above implements a custom TypeDescriptor for the ExifReader class.

/// <summary>
/// Implements a CustomTypeDescriptor for the ExifReader class
/// </summary>
internal class ExifReaderCustomTypeDescriptor : CustomTypeDescriptor
{
    /// <summary>
    /// List of custom fields
    /// </summary>
    private List<PropertyDescriptor> customFields 
      = new List<PropertyDescriptor>();

    /// <summary>
    ///  Initializes a new instance of the ExifReaderCustomTypeDescriptor class.
    /// </summary>
    /// <param name="parent">The parent custom type descriptor.</param>
    /// <param name="instance">Instance of ExifReader</param>
    public ExifReaderCustomTypeDescriptor(
      ICustomTypeDescriptor parent, object instance)
        : base(parent)
    {
        ExifReader exifReader = (ExifReader)instance;
        this.customFields.AddRange(
          exifReader.GetExifProperties().Select(
            ep => new ExifPropertyPropertyDescriptor(ep)));
    }

    /// <summary>
    /// Returns a collection of property descriptors for the object 
    /// represented by this type descriptor.
    /// </summary>
    /// <returns>A collection of property descriptors</returns>
    public override PropertyDescriptorCollection GetProperties()
    {
        return new PropertyDescriptorCollection(
          base.GetProperties().Cast<PropertyDescriptor>().Union(
            this.customFields).ToArray());
    }

    /// <summary>
    /// Returns a collection of property descriptors for the object 
    /// represented by this type descriptor.
    /// </summary>
    /// <param name="attributes">Attributes to filter on</param>
    /// <returns>A collection of property descriptors</returns>
    public override PropertyDescriptorCollection GetProperties(
        Attribute[] attributes)
    {
        return new PropertyDescriptorCollection(
          base.GetProperties(attributes).Cast<PropertyDescriptor>().Union(
            this.customFields).ToArray());
    }
}

For every Exif property the reader returns, a ExifPropertyPropertyDescriptor is created and added to the property list. It's ExifPropertyPropertyDescriptor which provides the property name, property value, property type etc. for the PropertyGrid.

/// <summary>
/// Implements a PropertyDescriptor for ExifProperty 
/// that returns the descriptive
/// string representation of the property's current value.
/// </summary>
internal class ExifPropertyPropertyDescriptor : PropertyDescriptor
{
    /// <summary>
    /// Initializes a new instance of the ExifPropertyPropertyDescriptor class.
    /// </summary>
    /// <param name="exifProperty">The ExifProperty to use with 
    /// this instance</param>
     public ExifPropertyPropertyDescriptor(ExifProperty exifProperty)
        : base(exifProperty.ExifPropertyName, new Attribute[1] 
            { new CategoryAttribute(exifProperty.ExifPropertyCategory) })
    {
        this.ExifProperty = exifProperty;
    }       
    
    /// <summary>
    /// Gets the ExifProperty associated with this instance
    /// </summary>
    public ExifProperty ExifProperty { get; private set; }

    /// <summary>
    /// Gets the type of the component this property is bound to
    /// </summary>
    public override Type ComponentType
    {
        get { return typeof(ExifReader); }
    }

     . . .

    /// <summary>
    /// Gets the type of the property.
    /// </summary>
    public override Type PropertyType
    {
        get { return typeof(string); }
    }

    . . .

    /// <summary>
    /// Gets the current value of the property
    /// </summary>
    /// <param name="component">The associated component</param>
    /// <returns>The property value</returns>
    public override object GetValue(object component)
    {
        return this.ExifProperty.ToString();
    }

    . . .    
}

In the partially snipped code listing, I have highlighted the important areas. We use ExifProperty.ExifPropertyName as the name of the property, and set the type of the property as a String. And finally for the property value, we call ToString() on the ExifProperty member. I thought of specifying actual data types instead of making them all Strings, but since this is a reader class and there is no plan for writer-support in the foreseeable future, I didn't think it worth the effort. And obviously PropertyGrid support is a convenience and not a necessity, and there are far more flexible ways to use the class as shown in the WPF demo application.

Thank you if you made it this far, and please feel free to pass on your criticism and other feedback via the forum attached to this article.

History

  • March 28, 2010 - Article first published

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Nish Sivakumar

United States United States
Nish is a real nice guy who has been writing code since 1990 when he first got his hands on an 8088 with 640 KB RAM. Originally from sunny Trivandrum in India, he has been living in various places over the past few years and often thinks it’s time he settled down somewhere.
 
Nish has been a Microsoft Visual C++ MVP since October, 2002 - awfully nice of Microsoft, he thinks. He maintains an MVP tips and tricks web site - www.voidnish.com where you can find a consolidated list of his articles, writings and ideas on VC++, MFC, .NET and C++/CLI. Oh, and you might want to check out his blog on C++/CLI, MFC, .NET and a lot of other stuff - blog.voidnish.com.
 
Nish loves reading Science Fiction, P G Wodehouse and Agatha Christie, and also fancies himself to be a decent writer of sorts. He has authored a romantic comedy Summer Love and Some more Cricket as well as a programming book – Extending MFC applications with the .NET Framework.
 
Nish's latest book C++/CLI in Action published by Manning Publications is now available for purchase. You can read more about the book on his blog.
 
Despite his wife's attempts to get him into cooking, his best effort so far has been a badly done omelette. Some day, he hopes to be a good cook, and to cook a tasty dinner for his wife.

Comments and Discussions

 
QuestionQuestion iPhone 3Gs Altitude and GPS Numbers Strange PinmemberMember 80638519-Sep-12 10:50 
GeneralMy vote of 5 Pinmembermanoj kumar choubey26-Feb-12 21:26 
GeneralMy vote of 5 PinmemberSAKryukov8-Feb-11 10:41 
GeneralMy vote of 5 PinmemberDaveX862-Dec-10 7:31 
Generalgood stuff PinmemberMubi | www.mrmubi.com30-Jul-10 12:35 
GeneralThank you! Pinmemberlavaoipockpock3-Jul-10 20:09 
QuestionCompile Errors on VS2008 & Net 3.5 PinmemberRichard Henley16-Apr-10 9:21 
QuestionWhat do you use to format your PRE sections to highlight parts of it??? PinmvpSacha Barber8-Apr-10 1:24 
AnswerRe: What do you use to format your PRE sections to highlight parts of it??? PinmvpNishant Sivakumar8-Apr-10 1:43 
GeneralRe: What do you use to format your PRE sections to highlight parts of it??? PinmvpSacha Barber8-Apr-10 1:49 
Cool thanks Nish.
Sacha Barber
  • Microsoft Visual C# MVP 2008-2010
  • Codeproject MVP 2008-2010
Your best friend is you.
I'm my best friend too. We share the same views, and hardly ever argue
 
My Blog : sachabarber.net

GeneralRe: What do you use to format your PRE sections to highlight parts of it??? PinmvpNishant Sivakumar8-Apr-10 1:50 
GeneralVery nice Pinmemberdigital man31-Mar-10 4:07 
GeneralRe: Very nice PinmvpNishant Sivakumar31-Mar-10 4:17 
GeneralGreat Article - Keep up the good work! PinmemberAlan Beasley31-Mar-10 1:27 
GeneralRe: Great Article - Keep up the good work! PinmvpNishant Sivakumar31-Mar-10 1:52 
GeneralVery very good PinmvpSacha Barber29-Mar-10 6:21 
GeneralRe: Very very good PinmvpNishant Sivakumar29-Mar-10 16:02 
GeneralRe: Very very good PinmvpSacha Barber29-Mar-10 19:59 
GeneralExcellent PinmvpMd. Marufuzzaman29-Mar-10 4:29 
GeneralRe: Excellent PinmvpNishant Sivakumar29-Mar-10 16:01 
GeneralNice, very detailed and informative PinmemberRama Krishna Vavilala29-Mar-10 3:41 
GeneralRe: Nice, very detailed and informative PinmvpNishant Sivakumar29-Mar-10 16:01 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Mobile
Web02 | 2.8.141015.1 | Last Updated 29 Mar 2010
Article Copyright 2010 by Nish Sivakumar
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid