View difference between Paste ID: Zevp8tuE and JP3z9sxV

 class MyClass : INotifyPropertyChanged
 {
     private string _foo;
     public string Foo
     {
         get { return _foo; }
         set
         {
             _foo = value;
-            OnPropertyChanged(() => Foo, () => Baz);
+            OnPropertyChanged(() => new { Foo, Baz });
         }
     }
 
     private int _bar;
     public int Bar
     {
         get { return _bar; }
         set
         {
             _bar = value;
-            OnPropertyChanged(() => Bar, () => Baz);
+            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(params Expression<Func<object>>[] propertySelectors)
+    protected void OnPropertyChanged<T>(Expression<Func<T>> propertySelector)
     {
-        foreach (var expr in propertySelectors)
+        foreach (string name in ExtractPropertyNames(propertySelector))
         {
-            OnPropertyChanged(ExtractPropertyName(expr));
+            OnPropertyChanged(name);
         }
     }
 
-    protected static string ExtractPropertyName(Expression<Func<object>> propertySelector)
+    protected static string[] ExtractPropertyNames<T>(Expression<Func<T>> propertySelector)
     {
         var memberExpr = propertySelector.Body as MemberExpression;
-        if (memberExpr == null)
+
             return new[] { memberExpr.Member.Name };
-            // Handle boxing of value types
+
-            var boxingExpr = propertySelector.Body as UnaryExpression;
+        // Handle anonymous type
-            if (boxingExpr != null && boxingExpr.NodeType == ExpressionType.Convert && boxingExpr.Type == typeof(object))
+        var newExpr = propertySelector.Body as NewExpression;
         if (newExpr != null)
-                memberExpr = boxingExpr.Operand as MemberExpression;
+
             var names = new List<string>();
             foreach (var arg in newExpr.Arguments)
             {
-            return memberExpr.Member.Name;
+                memberExpr = arg as MemberExpression;
-        throw new ArgumentException("Only member access expressions are supported");
+                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");
     }
 }