<code><pre lang="html4strict" line="1">
<h3>Syntax Highlighting w/ GeSHi</h3>
<div class="syntaxHighlighting">A Syntax Highlighting Example</div>
<p><em>Emphasis</em> with <strong>strong</strong> text</p>
</ pre></code> <!--The space is intentional to avoid ending my own pre tag in this post-->

public abstract class BaseModel : INotifyPropertyChanging, INotifyPropertyChanged
{
   public event PropertyChangingEventHandler PropertyChanging;
   public event PropertyChangedEventHandler PropertyChanged;
 
   protected virtual void OnPropertyChanging(string propertyName)
   {
      if (this.PropertyChanging != null)
      {
         this.PropertyChanging(
            this, 
            new PropertyChangingEventArgs(propertyName));
      }
   }
 
   protected virtual void OnPropertyChanged(string propertyName)
   {
      if (this.PropertyChanged != null)
      {
         this.PropertyChanged(
            this, 
            new PropertyChangedEventArgs(propertyName));
      }
   }
}
 
public class BusinessModel : BaseModel
{
   private string value;
 
   public string Value
   {
      get
      {
         return this.value;
      }
 
      set
      {
         this.OnPropertyChanging("Value");
         this.value = value;
         this.OnPropertyChanged("Value");
      }
   }
}

public abstract class BaseModel : INotifyPropertyChanging, INotifyPropertyChanged
{
   public event PropertyChangingEventHandler PropertyChanging;
   public event PropertyChangedEventHandler PropertyChanged;
 
   protected virtual void OnPropertyChanging<T>(Expression<Func<T>> expression)
   {
      var memberExpression = expression.Body as MemberExpression;
 
      if (this.PropertyChanging != null)
      {
         this.PropertyChanging(
            this, 
            new PropertyChangingEventArgs(memberExpression.Member.Name));
      }
   }
 
   protected virtual void OnPropertyChanged<T>(Expression<Func<T>> expression)
   {
      var memberExpression = expression.Body as MemberExpression;
 
      if (this.PropetyChanged != null)
      {
         this.PropertyChanged(
            this, 
            new PropertyChangedEventArgs(memberExpression.Member.Name));
      }
   }
}
 
public class BusinessModel : BaseModel
{
   private string value;
 
   public string Value
   {
      get
      {
         return this.value;
      }
 
      set
      {
         this.OnPropertyChanging(() => this.Value);
         this.value = value;
         this.OnPropertyChanged(() => this.Value);
      }
   }
}

public class MyObservable : MemberNotifier // all the goodies
{
   private string value;
 
   public string Value
   {
      get { return this.value; }
 
      set
      {
         this.OnChanging(() => this.Value);
         this.value = value;
         this.OnChanged(() => this.Value);
      }
   }
}
 
public class ObservableTestFixture
{
   [Fact] // xUnit test
   public void TestMemberNotifications()
   {
      var observable = new MyObservable();
      int changingCount = 0, changedCount = 0;
      string changingPropertyName = null, changedPropertyName = null;
 
      // the anonymous delegate is passed directly into the function call
      // so, there are no managed references to clean up
      // However, you should use "UnregisterObserver" if the delegate is assigned to an object instance
      observable.RegisterObserver((o, args) =>
         {
            // for the record, I don't like these "is" checks... it's most definately smelly code
            // however, the interface for "args" can be implemented using any method (enums, bools, etc.)
            if (args is MemberChangingNotification)
            {
               changingCount++;
               changingPropertyName = arg.MemberExpression.Member.Name;
            }
            else if (args is MemberChangedNotification)
            {
               changedCount++;
               changedPropertyName = arg.MemberExpression.Member.Name;
            }
         });
 
      observable.Value = "test";
 
      // strongly-typed sweetness
      var expectedPropertyName = ExpressionHelper.GetMember(() => see.Value).Name;
 
      Assert.AreEqual(1, changingCount);
      Assert.AreEqual(expectedPropertyName, changingPropertyName);
      Assert.AreEqual(1, changedCount);
      Assert.AreEqual(expectedPropertyName, changedPropertyName);
   }
}

// I'll take a shot at Wordpress coding... where's my intellisense?!
public abstract class PropertyNotifier : 
   MemberNotifier, 
   INotifyPropertyChanging, 
   INotifyPropertyChanged
{
   // the only requirement for INotifyPropertyChanging 
   public event PropertyChangingEventHandler PropertyChanging;
 
   // the only requirement for INotifyPropertyChanged
   public event PropertyChangedEventHandler PropertyChanged;
 
   protected override void OnChanging<T>(Expression<Func<T>> expression)
   {
      base.OnChanging(expression); // notify using the Observable pattern
 
      if (this.PropertyChanging != null)
      {
         var memberExpression = expression.Body as MemberExpression;
 
         // notify using events
         this.PropertyChanging(
            this, 
            new PropertyChanging(memberExpression.Member.Name));
      }
   }
 
   protected void OnChanged<T>(Expression<Func<T>> expression)
   {
      base.OnChanged(expression); // notify using the Observable pattern
 
      if (this.PropertyChanged != null)
      {
         var memberExpression = expression.Body as MemberExpression;
 
         // notify using events
         this.PropertyChanged(
            this, 
            new PropertyChanged(memberExpression.Member.Name));
      }
   }
 
   // wrap a setter in Changing and Changed notifications
   protected void SetWithNotifications<T>(
      Expression<Func<T>> expression, 
      Action setter)
   {
      this.OnPropertyChanging(expression);
      setter();
      this.OnPropertyChanged(expression);
   }
}
 
// now, implementing becomes incredibly simple!
public class MyObservable : PropertyNotifier
{
   private string value;
 
   public string Value
   {
      get { return this.value; }
 
      set
      {
         // pass the member expression and the setter action delegate
         this.SetWithNotifications(() => this.Value, () => this.value = value);
      }
   }
}
 
// what about multiple notifications?
public class MyObservablePerson : PropertyNotifier
{
   private string firstName;
   private string lastName;
 
   public string FirstName
   {
      get { return this.firstName; }
      set
      {
         // ... [input validation ?] ...
 
         this.SetWithNotifications(
            () => this.FirstName, // member expression
            () => // setter
            {
               // wrap setter with change notifications for FullName
               this.OnPropertyChanging(() => this.FullName);
               this.firstName = value;
               this.OnPropertyChanged(() => this.FullName);
            });
      }
 
   public string LastName
   {
      get { return this.lastName; }
      set
      {
         // ... [input validation] ...
         this.SetWithNotifications(
            () => this.LastName, 
            () => 
            {
               this.OnPropertyChanging(() => this.FullName);
               this.lastName = value;
               this.OnPropertyChanged(() => this.FullName);
            });
      }
 
      public string FullName
      {
         get      
         {
            return String.Format(
               CultureInfo.CurrentCulture, 
               "{1}, {0}", 
               this.FirstName, 
               this.LastName);
         }
      }
   }
}
 
/*
   FYI: You could also overload the SetWithNotifications method 
   to accept a primary member expression for the setter and a
   list of secondary member expressions for notification...
   The call would end up looking something like:
      this.SetWithNotifications(
         () => this.Value, 
         {
            () => this.DependantValue1,
            () => this.DependantValue2,
            () => this.DependantValue3
         },
         this.value = value);
 
   The method could simply iterate the dependencies,
   calling Changing() and Changed() for each.
*/