Concise PropertyChanged Implementation

public string MyProperty {

	get { return _MyProperty; }

	set {
		if (value == _MyProperty) return;

		_MyProperty = value;

		OnPropertyChanged(NameOf(MyProperty));

	    }
}

Public Property MyProperty() As String

            Get
                Return _MyProperty
            End Get
            Set(ByVal value As String)

                If value = _MyProperty Then Return

                _MyProperty = value

                OnPropertyChanged(NameOf(MyProperty))

            End Set

        End Property

get { return GetValue(() => MyProperty); }

get { return _myProperty; }

set { SetValue(() => MyProperty, value); }

set {
     if (value == _myProperty) return; 
     _myProperty = value; 
     OnPropertyChanged(NameOf(MyProperty)); 
    }

private string _myValue;
public string MyValue {
    get { return _myValue; }
    set { if (value == _myValue) return;
    _myValue = value;
    OnPropertyChanged(nameof(MyValue));
}

public string MyValue {
    get { return GetValue(()=>MyValue); }
    set { SetValue(()=>MyValue, value); }
}

public string MyValue {
    get { return GetValue(()=>MyValue); }
    set { SetValue(()=>MyValue, value); }
}

get { return _myValue; }

get { return GetValue(()=>MyValue); }

set { if (value == _myValue) return;
   _myValue = value;
   OnPropertyChanged(nameof(MyValue));

set { SetValue(()=>MyValue, value); }

get { return _myValue; }

set { if (value == _myValue) return;...

Simon Bridge wrote:

so, you can't even type your 'simpler' code without including syntax errors and run-time inconsistencies? Do you even know the difference between Equals() and "=="?

Simon Bridge wrote:

with what will end up being thousands of additional keystrokes

Simon Bridge wrote:

and a completely unnecessary backing field for every property you create.

get { return GetValue(); }

set { SetValue(value); }

/// <summary>
/// sets a value on the model, raising <see cref="PropertyChangedBase.PropertyChanged"/> if the value is changing
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="memberExpression"></param>
/// <param name="value"></param>
/// <returns></returns>
public bool SetModelValue<T>(Expression<Func<T>> memberExpression, T value)
{
    var getter = GetGetter(memberExpression);
    var setter = GetSetter(memberExpression);

    if (EqualityComparer<T>.Default.Equals(value, getter.Invoke(Model)))
    {
        return false;
    }

    var body = memberExpression.Body as MemberExpression;
    if (body != null)
    {
        // set the value on the model
        setter.Invoke(Model, value);

        // raise the event:
        OnPropertyChanged(body.Member.Name);
    }

    return true;
}

/// <summary>
/// caches and returns a compiled getter to retrieve the property of the <see cref="Model"/> as specified by the member expression
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="member"></param>
/// <returns></returns>
Func<TModel, T> GetGetter<T>(Expression<Func<T>> member)
{
    // the compiled delegate:
    Func<TModel, T> func = null;

    // get the name of the property to retrieve from the model
    var name = ((MemberExpression)member.Body).Member.Name;

    // define a key to use for this getter in the dictionary
    var key  = $"get_{name}";

    // check the cache: is the getter already compiled?
    object f;
    if (m_values.TryGetValue(key, out f))
    {
        // retrieve the existing getter
        func = f as Func<TModel, T>;
    }
    if (func == null)
    {
        // compile a new getter:
        func = typeof(TModel).GetProperty(name).CompileGetter<TModel, T>();
        if (func != null)
        {
            // add into the dictionary:
            m_values[key] = func;
        }
    }

    // return the getter:
    return func;

}