OnPropertyChanged with lambda + anonymous type

class MyClass : INotifyPropertyChanged
{
    private string _foo;
    public string Foo
    {
        get { return _foo; }
        set
        {
            _foo = value;
            OnPropertyChanged(() => new { Foo, Baz });
        }
    }

    private int _bar;
    public int Bar
    {
        get { return _bar; }
        set
        {
            _bar = value;
            OnPropertyChanged(() => new { Bar, Baz });
        }
    }

    public string Baz
    {
        get { return _foo + _bar; }
    }

    public event PropertyChangedEventHandler PropertyChanged;

    protected virtual void OnPropertyChanged(string propertyName)
    {
        var handler = PropertyChanged;
        if (handler != null)
            handler(this, new PropertyChangedEventArgs(propertyName));
    }

    protected void OnPropertyChanged<T>(Expression<Func<T>> propertySelector)
    {
        foreach (string name in ExtractPropertyNames(propertySelector))
        {
            OnPropertyChanged(name);
        }
    }

    protected static string[] ExtractPropertyNames<T>(Expression<Func<T>> propertySelector)
    {
        var memberExpr = propertySelector.Body as MemberExpression;
        if (memberExpr != null)
            return new[] { memberExpr.Member.Name };

        // Handle anonymous type
        var newExpr = propertySelector.Body as NewExpression;
        if (newExpr != null)
        {
            var names = new List<string>();
            foreach (var arg in newExpr.Arguments)
            {
                memberExpr = arg as MemberExpression;
                if (arg == null)
                    throw new ArgumentException("Only member access expressions are supported in anonymous types");
                names.Add(memberExpr.Member.Name);
            }
            return names.ToArray();
        }

        throw new ArgumentException("Only member access expressions and anonymous type creation are supported");
    }
}