Question

I’ve recently started experimenting with DataBinding and implementing DependencyProperties for my custom classes. It all works fine and the possibilities are exciting, however, I came across a problem that may be only solvable by slightly modifying the overall class design. And I want to make sure this is the only option and I’m not missing anything.

So, my class stores information about video files the user imports into the application. Among other properties, it contains:

public class VideoFile {

    public string FilePath { get; protected set; }
    public uint ID { get; protected set; ]
    public string Extension { get { return Path.GetExtension(FilePath); } }
    public string FileName { get { return Path.GetFilename(FilePath); } }

}

So, I’ve successfully replaced FilePath with an DependencyProperty. However, in the UI, I mostly want to display just the filename, which uses some logic to provide its value. As far as I know, here are my options:

1. I could simply create DependencyProperties for FileName and Extension, and set their value in the constructor, but that’s redundant; I already have that information in the FilePath, so I want to avoid this option.
2. Create ValueConverters, one for displaying Filename and one for displaying Extension, and use them in my bindings.

I’ve only met ValueConverters briefly, so I’m not sure about it. Can I use them for this purpose? Or, have I just encountered one of the main reasons they exist? 🙂

And last but not least, can anyone think of a situation similar to this, when a ValueConverter is not the right way to go? I want to avoid jumping straight into them, only to realize it will not work because “that one” property just can’t be expressed in this way.

Answer 1

Don’t duplicate data.

Prefer Binding and an IValueConverter, because that way, whenever FilePath changes, Extension and FileName will be updated in the UI as well.

You could also, of course, raise PropertyChanged for them in FilePath‘s setter but that’s bad practice since FilePath should not have to care about who/what uses it.

The class then looks like:

public class VideoFile : INotifyPropertyChanged {

    string m_FilePath;
    public string FilePath 
    { 
       get { return m_FilePath; } 
       protected set
       {
          if(value != m_FilePath)
          {
             m_FilePath = value;
             RaisePropertyChanged(() => this.FilePath);
          }
       }
    }
    public uint ID { get; protected set; }

    #region INotifyPropertyChanged Members

    public event PropertyChangedEventHandler PropertyChanged;
    protected void RaisePropertyChanged<T>(Expression<Func<T>> _PropertyExpression)
    {
        RaisePropertyChanged(PropertySupport.ExtractPropertyName(_PropertyExpression));
    }

    protected void RaisePropertyChanged(String _Prop)
    {
        PropertyChangedEventHandler handler = this.PropertyChanged;
        if (handler != null)
        {
            handler(this, new PropertyChangedEventArgs(_Prop));
        }
    }

    #endregion
}

Please note that PropertySupport is part of Prism, but you can do without it by calling RaisePropertyChanged("FilePath"), it’s just neat to have type safety because if you change the property’s name you will have a compile-time error.