title: C# Explicit implementation of interface breaks my INotifyPropertyChanged
body: <p>This might be little bit stupid question but I could not find any work-around or think of any solutions to the following problem...</p>
  
  <pre><code>  public class Example: IExample, INotifyPropertyChanged
    {
      public Example()
      {
      }
  
      /// Does not works properly... 
      string fooString;
      string IExample.A
      {
          get { return this.fooString; }
          set
          {
              this.fooString= value;
              onPropertyChange("A");
          }
      }
  
      /// Works just fine
      string fooString;
      public string A
      {
          get { return this.fooString; }
          set
          {
              this.fooString= value;
              onPropertyChange("A");
          }
      }
  
      PropertyChangedEventHandler propertyChangedHandler;
  
      private void onPropertyChange(string propertyName)
      {
          if (this.propertyChangedHandler != null)
              propertyChangedHandler(this, new PropertyChangedEventArgs(propertyName));
      }
  
      event PropertyChangedEventHandler INotifyPropertyChanged.PropertyChanged
      {
          add { this.propertyChangedHandler += value; }
          remove { this.propertyChangedHandler -= value; }
      }
  
   }
  </code></pre>
  
  <p>As you can see from the code I have a class Example who implements from  INotifyPropertyChanged and my IExample interface who has 1 property A.</p>
  
  <p>Since I am using <strong>Explicit interface implementation</strong> I am forced to refer to my <strong>A</strong> through my <strong>IExample interface</strong></p>
  
  <p>And that is where my problem is. Since <strong>A</strong> is coming from <strong>IExamle Explicitly</strong> when value changes <strong>INotifyPropertyChanged</strong> does not gets fired... </p>
  
  <p>Which makes sense. </p>
  
  <p>Any thoughts/ideas how to keep <strong>Explicit interface implementation</strong> and INotifyPropertyChanged and still get the job done?</p>
  
  <p>You might ask why I am obsessed with <strong>Explicit interface implementation</strong></p>
  
  <pre><code>1) it's cool [I know horrible reason]
  2) its clarity and better code readability [mostly because of this]
  3) It forces you to use Interface   
  </code></pre>
  
  <p>Btw Feel free to critique INotifyPropertyChanged implementation. I feel I can re-implement this is a way so that it can handle <strong>Explicit inheritance</strong></p>
  
  <p>Thank you all in advance. </p>
  
  <p>[Edit] Changed "explicit inheritance vs explicit interface implementation" - Like Daniel Corrected me, Added Implicit Inheritance code. Obviously one of the inheritances should be commented out...</p>