Below is how I'm solving the problem of converting between data and presentation types, I'd like to know if that's a good way to go about it, and if not, what would be a better way to go about it.I already had an IViewModel interface:/// <summary>/// An interface for a ViewModel./// </summary>public interface IViewModel : INotifyPropertyChanged{    /// <summary>    /// Notifies listener that the value of the specified property has changed.    /// </summary>    void NotifyPropertyChanged<TProperty>(Expression<Func<TProperty>> property);    /// <summary>    /// Notifies listener that the value of the specified property has changed.    /// </summary>    void NotifyPropertyChanged(string propertyName);}So I added an IViewModel<T> interface that extends it:/// <summary>/// An interface for a ViewModel that encapsulates an entity type./// </summary>/// <typeparam name=T>The entity interface type.</typeparam>public interface IViewModel<T> : IViewModel where T : class{    /// <summary>    /// A method that returns the encapsulated entity interface.    /// </summary>    /// <returns>Returns an interface to the encapsulated entity.</returns>    T ToEntity();}Then to facilitate usage, I implemented it in a base class:/// <summary>/// Base class to derive ViewModel implementations that encapsulate an Entity type./// </summary>/// <typeparam name=T>The entity type.</typeparam>public abstract class ViewModelBase<T> : IViewModel<T> where T : class{    protected readonly T EntityType;    /// <summary>    /// Initializes a new instance of the <see cref=ViewModelBase{T}/> class.    /// </summary>    /// <param name=entityType>An instance of the entity type to encapsulate.</param>    protected ViewModelBase(T entityType)    {        EntityType = entityType;        ReflectTypeProperties();    }    public T ToEntity()    {        return EntityType;    }    #region INotifyPropertyChanged implementation    /// <summary>    /// Occurs when a property value changes.    /// </summary>    public event PropertyChangedEventHandler PropertyChanged;    /// <summary>    /// Notifies listener that the value of the specified property has changed.    /// </summary>    /// <param name=propertyName>The name of the property to notify about.</param>    public void NotifyPropertyChanged(string propertyName)    {        Action notify;        _propertyNotifications.TryGetValue(propertyName, out notify);        if (notify != null) notify();    }    /// <summary>    /// Notifies listener that the value of the specified property has changed.    /// </summary>    /// <typeparam name=TProperty>The type of the property (inferred).</typeparam>    /// <param name=property>An expression that selects a property, like <c>() => PropertyName</c>.</param>    public void NotifyPropertyChanged<TProperty>(Expression<Func<TProperty>> property)    {        NotifyPropertyChanged(PropertyName(property));    }    private void NotifyPropertyChanged(object sender, PropertyChangedEventArgs e)    {        if (PropertyChanged != null) PropertyChanged(sender, e);    }    private IDictionary<string, Action> _propertyNotifications;    /// <summary>    /// Loads the names of all properties of the most derived type into a    /// Dictionary where each entry (property name) points to a delegate that    /// calls <see cref=NotifyPropertyChanged/> for the corresponding property.    /// </summary>    private void ReflectTypeProperties()    {        var viewModelProperties = GetType().GetProperties().Where(p => p.CanWrite); // uses reflection (slow)        _propertyNotifications = viewModelProperties                                        .Select(property => new KeyValuePair<string, Action>(property.Name,                                                      () => NotifyPropertyChanged(this, new PropertyChangedEventArgs(property.Name))))                                        .ToDictionary(kv => kv.Key, kv => kv.Value);    }    /// <summary>    /// Returns the name of a property in a LINQ Expression such as '<code>() => Property</code>'.    /// Used for strongly-typed INotifyPropertyChanged implementation.    /// </summary>    protected static string PropertyName<TProperty>(Expression<Func<TProperty>> property)    {        var lambda = (LambdaExpression)property;        MemberExpression memberExpression;        var body = lambda.Body as UnaryExpression;        if (body == null)            memberExpression = (MemberExpression)lambda.Body;        else        {            var unaryExpression = body;            memberExpression = (MemberExpression)unaryExpression.Operand;        }        return memberExpression.Member.Name;    }    #endregion}This leaves me with clean & focused ViewModel classes that only expose what's meant to be displayed, while retaining the knowledge of the precious encapsulated Id:/// <summary>/// Encapsulates a <see cref=ISomeEntity/> implementation for presentation purposes./// </summary>public class SomeEntityViewModel : ViewModelBase<ISomeEntity>, ISelectable, IDeletable{    /// <summary>    /// Encapsulates specified entity in a presentation type.    /// </summary>    /// <param name=poco>The entity to be encapsulated.</param>    public SomeEntityViewModel(ISomeEntity poco) : base(poco) { }    /// <summary>    /// A short description for the thing.    /// </summary>    public string Description     {         get { return EntityType.Description; }         set { EntityType.Description = value; NotifyPropertyChanged(() => Description); }     }    private bool _isSelected;    public bool IsSelected     {         get { return _isSelected; }         set { _isSelected = value; NotifyPropertyChanged(() => IsSelected); }     }    private bool _isDeleted;    public bool IsDeleted     {         get { return _isDeleted; }         set { _isDeleted = value; NotifyPropertyChanged(() => IsDeleted); }     }}Bonus question: is my implementation of INotifyPropertyChanged overkill?
Converting between data and presentation types
c#;mvvm
T ToEntity();To me, ToEntity() implies some sort of conversion action. A better option might be T GetEntity() or even a property called Entity.protected readonly T EntityType;EntityType is a bad name for this field, because it does not contain a type, it contains the entity. Because of that, something like Entity might be better.Also, you might want to consider making this into a property. The reasons for not using public fields also apply to protected fields (though not as strongly).private IDictionary<string, Action> _propertyNotifications;This seems completely unnecessary. Unless you know that this actually makes measurable improvement in performance (which I seriously doubt), just raise the event.var lambda = (LambdaExpression)property;var unaryExpression = body;These two lines are unnecessary and I think they also don't improve readability.memberExpression = (MemberExpression)unaryExpression.Operand;If you're expecting only some specific UnaryExpressions, then I would check that those are actually what you have. For example, I think your code would work with () => !BoolProperty, which I think it shouldn't.