INotifyPropertyChanged Interface

>For change notification to occur in a binding between a bound client and a data source, your bound type should either:
>Implement the INotifyPropertyChanged interface (preferred).
>Provide a change event for each property of the bound type.
>Do not do both.

Ok, but binding is not working if change event is of a type different from EventHandler. In this case, does not work INotifyPropertyChanged Interface, nor PropertyChanged magic. For example:

    /// <summary>
    /// In this class binding is NOT WORKING.
    /// </summary>
    public class Foo: INotifyPropertyChanged
    {
        string text;

        public string Text
        {
            get { return text; }
            set
            {
                text = value;
                OnTextChanged();
            }
        }

        protected void OnTextChanged()
        {
            if (TextChanged != null)
                TextChanged(this, new MyEventArgs());
            if (PropertyChanged != null)
                PropertyChanged(this, new PropertyChangedEventArgs("Text"));
        }

        //Here binding is not working, because type is different from EventHandler
        public event EventHandler<MyEventArgs> TextChanged;

        //And here binding is not working too, because declared TextChanged event
        public event PropertyChangedEventHandler PropertyChanged;
    } 

public property decimal CurrentBalance {
  get { return this.currentBalance; }
  set {
    if(value != this.currentBalance) {
      this.currentBalance = value;
      OnPropertyChanged(() => CurrentBalance);
    }
  }
}

• Avoids garbage by caching PropertyChangedEventArgs instances. An application has a finite number of properties that report changes, typically in the dozens or hundreds, but do your own profiling to see if the cache is beneficial in your own applications.
• It supports F2 refactoring by using the now popular lamba expression trick to obtain the property name from code instead of using a string
• The event is raised in a thread-safe manner
• Serialization doesn't save event subscribers. Usually, subscribers are GUI controls like DataGrids and TextBoxes, aka things you do not want to serialize. If you do wish to serialize event subscriptions, either modify this implementation or use the OnDeserialized callback (search MSDN for OnDeserializedAttribute) to re-establish the subscription after deserialization.

I hope this can serve as a solid foundation or at least demonstrates some tricks to efficiently deal with property change notifications. I followed established conventions and best practices wherever possible.

/// <summary>Base class for objects that support property change notifications</summary>
[Serializable]
public abstract class Observable : INotifyPropertyChanged {

  /// <summary>Raised when a property of the instance has changed its value</summary>
  [field:NonSerialized]
  public event PropertyChangedEventHandler PropertyChanged;

  /// <summary>Initializes a new trackable object</summary>
  static Observable() {
    eventArgumentCache = new ConcurrentDictionary<string, PropertyChangedEventArgs>();
  }

  /// <summary>Triggers the PropertyChanged event for the specified property</summary>
  /// <param name="propertyName">Name of the property that has changed its value</param>
  /// <remarks>
  ///   This notification should be fired post-change, i.e. when the property has
  ///   already changed its value.
  /// </remarks>
  protected virtual void OnPropertyChanged(string propertyName) {
    enforceChangedPropertyExists(propertyName);

    PropertyChangedEventHandler copy = PropertyChanged;
    if(copy != null) {
      copy(this, getOrCreatePropertyChangedEventArgs(propertyName));
    }
  }

  /// <summary>Triggers the PropertyChanged event for the specified property</summary>
  /// <param name="property">
  ///        Lambda expression for the property that will be reported to have changed
  ///    </param>
  /// <remarks>
  ///   This notification should be fired post-change, i.e. when the property has
  ///   already changed its value.
  /// </remarks>
  protected void OnPropertyChanged<TProperty>(Expression<Func<TProperty>> property) {
    var lambda = (LambdaExpression)property;

    MemberExpression memberExpression;
    {
      var unaryExpression = lambda.Body as UnaryExpression;
      if(unaryExpression != null) {
        memberExpression = (MemberExpression)unaryExpression.Operand;
      } else {
        memberExpression = (MemberExpression)lambda.Body;
      }
    }

    OnPropertyChanged(memberExpression.Member.Name);
  }

  /// <summary>
  ///   Looks up a property changed event argument container for the specified property
  /// </summary>
  /// <param name="propertyName">
  ///   Property whose event argument container will be looked up
  /// </param>
  /// <returns>The event argument container for a property of the specified name</returns>
  private PropertyChangedEventArgs getOrCreatePropertyChangedEventArgs(string propertyName) {
    PropertyChangedEventArgs arguments;
    if(eventArgumentCache.TryGetValue(propertyName, out arguments)) {
      return arguments;
    }

    return eventArgumentCache.GetOrAdd(
      propertyName, new PropertyChangedEventArgs(propertyName)
    );
  }

  /// <summary>Ensures that a property with the specified name exists in the type</summary>
  /// <param name="propertyName">Property name that will be checked</param>
  [Conditional("DEBUG")]
  private void enforceChangedPropertyExists(string propertyName) {
    PropertyInfo property = GetType().GetProperty(propertyName);
    if(property == null) {
      throw new ArgumentException(
        string.Format(
          "Type '{0}' tried to raise a change notifcation for property '{1}', " +
          "but no such property exists!",
          GetType().Name, propertyName
        ),
        "propertyName"
      );
    }
  }

  /// <summary>
  ///   Caches PropertyChangedEventArgs instances to prevent excessive garbage production
  /// </summary>
  private static readonly ConcurrentDictionary<
    string, PropertyChangedEventArgs
  > eventArgumentCache;

}