BindableBase.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="BindableBase.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>This class implements INotifyPropertyChanged</summary>
//-----------------------------------------------------------------------
using System;
using System.ComponentModel;
 
namespace Csla.Core
{
  [Serializable()]
  public abstract class BindableBase : 
    MobileObject, 
    INotifyPropertyChanged, 
    INotifyPropertyChanging
  {
    protected BindableBase()
    { }
 
    [NonSerialized()]
    private PropertyChangedEventHandler _nonSerializableChangedHandlers;
    private PropertyChangedEventHandler _serializableChangedHandlers;
 
    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", 
      "CA1062:ValidateArgumentsOfPublicMethods")]
    public event PropertyChangedEventHandler PropertyChanged
    {
      add
      {
        if (ShouldHandlerSerialize(value))
          _serializableChangedHandlers = (PropertyChangedEventHandler)
            System.Delegate.Combine(_serializableChangedHandlers, value);
        else
          _nonSerializableChangedHandlers = (PropertyChangedEventHandler)
            System.Delegate.Combine(_nonSerializableChangedHandlers, value);
      }
      remove
      {
          if (ShouldHandlerSerialize(value))
          _serializableChangedHandlers = (PropertyChangedEventHandler)
            System.Delegate.Remove(_serializableChangedHandlers, value);
        else
          _nonSerializableChangedHandlers = (PropertyChangedEventHandler)
            System.Delegate.Remove(_nonSerializableChangedHandlers, value);
      }
    }
 
    protected virtual bool ShouldHandlerSerialize(PropertyChangedEventHandler value)
    {
      return value.Method.IsPublic &&
             value.Method.DeclaringType != null &&
             (value.Method.DeclaringType.IsSerializable || value.Method.IsStatic);
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void OnPropertyChanged(string propertyName)
    {
      if (_nonSerializableChangedHandlers != null)
        _nonSerializableChangedHandlers.Invoke(this,
          new PropertyChangedEventArgs(propertyName));
      if (_serializableChangedHandlers != null)
        _serializableChangedHandlers.Invoke(this,
          new PropertyChangedEventArgs(propertyName));
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void OnMetaPropertyChanged(string propertyName)
    {
      if (_nonSerializableChangedHandlers != null)
        _nonSerializableChangedHandlers.Invoke(this,
          new MetaPropertyChangedEventArgs(propertyName));
      if (_serializableChangedHandlers != null)
        _serializableChangedHandlers.Invoke(this,
          new MetaPropertyChangedEventArgs(propertyName));
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void OnPropertyChanged(IPropertyInfo propertyInfo)
    {
      OnPropertyChanged(propertyInfo.Name);
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void OnIsDirtyChanged()
    {
      OnUnknownPropertyChanged();
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void OnUnknownPropertyChanged()
    {
      OnPropertyChanged(string.Empty);
    }
 
    [NonSerialized()]
    private PropertyChangingEventHandler _nonSerializableChangingHandlers;
    private PropertyChangingEventHandler _serializableChangingHandlers;
 
    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design",
      "CA1062:ValidateArgumentsOfPublicMethods")]
    public event PropertyChangingEventHandler PropertyChanging
    {
      add
      {
          if (ShouldHandlerSerialize(value))
          _serializableChangingHandlers = (PropertyChangingEventHandler)
            System.Delegate.Combine(_serializableChangingHandlers, value);
        else
          _nonSerializableChangingHandlers = (PropertyChangingEventHandler)
            System.Delegate.Combine(_nonSerializableChangingHandlers, value);
      }
      remove
      {
          if (ShouldHandlerSerialize(value))
          _serializableChangingHandlers = (PropertyChangingEventHandler)
            System.Delegate.Remove(_serializableChangingHandlers, value);
        else
          _nonSerializableChangingHandlers = (PropertyChangingEventHandler)
            System.Delegate.Remove(_nonSerializableChangingHandlers, value);
      }
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void OnIsDirtyChanging()
    {
      OnUnknownPropertyChanging();
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void OnUnknownPropertyChanging()
    {
      OnPropertyChanging(string.Empty);
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void OnPropertyChanging(string propertyName)
    {
      if (_nonSerializableChangingHandlers != null)
        _nonSerializableChangingHandlers.Invoke(this,
          new PropertyChangingEventArgs(propertyName));
      if (_serializableChangingHandlers != null)
        _serializableChangingHandlers.Invoke(this,
          new PropertyChangingEventArgs(propertyName));
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void OnPropertyChanging(IPropertyInfo propertyInfo)
    {
      OnPropertyChanging(propertyInfo.Name);
    }
 
    protected virtual bool ShouldHandlerSerialize(PropertyChangingEventHandler value)
    {
      return value.Method.IsPublic &&
             value.Method.DeclaringType != null &&
             (value.Method.DeclaringType.IsSerializable || value.Method.IsStatic);
    }
  }
}