Core/BusinessBase.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="BusinessBase.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>This is the non-generic base class from which most</summary>
//-----------------------------------------------------------------------
using System;
using System.Collections.Concurrent;
using System.Diagnostics;
using System.Linq;
using System.Collections.Generic;
using System.ComponentModel;
using System.Threading.Tasks;
using Csla.Properties;
using System.Collections.Specialized;
using System.ComponentModel.DataAnnotations;
using System.Collections.ObjectModel;
using Csla.Core.LoadManager;
using Csla.Reflection;
using Csla.Server;
using Csla.Security;
using Csla.Serialization.Mobile;
using Csla.Rules;
using System.Security;
using Csla.Core.FieldManager;
using System.Reflection;
using System.Collections;
 
namespace Csla.Core
{
 
#if TESTING
  [System.Diagnostics.DebuggerStepThrough]
#endif
  [Serializable]
  public abstract class BusinessBase : UndoableBase,
    IEditableBusinessObject,
    IEditableObject,
    ICloneable,
    IAuthorizeReadWrite,
    IParent,
    IDataPortalTarget,
    IManageProperties,
    Rules.IHostRules,
    ICheckRules,
    INotifyBusy,
    INotifyChildChanged,
    ISerializationNotification,
    IDataErrorInfo,
    INotifyDataErrorInfo,
    IUseFieldManager,
    IUseBusinessRules
  {
 
    protected BusinessBase()
    { }
 
    protected override void OnApplicationContextSet()
    {
      InitializeIdentity();
      Initialize();
      InitializeBusinessRules();
    }
 
    #region Initialize
 
    protected virtual void Initialize()
    { /* allows subclass to initialize events before any other activity occurs */ }
 
    #endregion
 
    #region Identity
 
    private int _identity = -1;
 
    int IBusinessObject.Identity
    {
      get { return _identity; }
    }
 
    private void InitializeIdentity()
    {
      _identity = ((IParent)this).GetNextIdentity(_identity);
    }
 
    [NonSerialized]
    [NotUndoable]
    private IdentityManager _identityManager;
 
    int IParent.GetNextIdentity(int current)
    {
      if (this.Parent != null)
      {
        return this.Parent.GetNextIdentity(current);
      }
      else
      {
        if (_identityManager == null)
          _identityManager = new IdentityManager();
        return _identityManager.GetNextIdentity(current);
      }
    }
    
    #endregion
 
    #region Parent/Child link
 
    [NotUndoable]
    [NonSerialized]
    private IParent _parent;
 
    [Browsable(false)]
    [Display(AutoGenerateField = false)]
    [ScaffoldColumn(false)]
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public Core.IParent Parent
    {
      get { return _parent; }
    }
 
    protected virtual void SetParent(Core.IParent parent)
    {
      _parent = parent;
      _identityManager = null;
      InitializeIdentity();
    }
 
    #endregion
 
    #region IsNew, IsDeleted, IsDirty, IsSavable
 
    // keep track of whether we are new, deleted or dirty
    private bool _isNew = true;
    private bool _isDeleted;
    private bool _isDirty = true;
 
    [Browsable(false)]
    [Display(AutoGenerateField = false)]
    [ScaffoldColumn(false)]
    public bool IsNew
    {
      get { return _isNew; }
    }
 
    [Browsable(false)]
    [Display(AutoGenerateField = false)]
    [ScaffoldColumn(false)]
    public bool IsDeleted
    {
      get { return _isDeleted; }
    }
 
    [Browsable(false)]
    [Display(AutoGenerateField = false)]
    [ScaffoldColumn(false)]
    public virtual bool IsDirty
    {
      get { return IsSelfDirty || (_fieldManager != null && FieldManager.IsDirty()); }
    }
 
    [Browsable(false)]
    [Display(AutoGenerateField = false)]
    [ScaffoldColumn(false)]
    public virtual bool IsSelfDirty
    {
      get { return _isDirty; }
    }
 
    protected virtual void MarkNew()
    {
      _isNew = true;
      _isDeleted = false;
      MetaPropertyHasChanged("IsNew");
      MetaPropertyHasChanged("IsDeleted");
      MarkDirty();
    }
 
    protected virtual void MarkOld()
    {
      _isNew = false;
      MetaPropertyHasChanged("IsNew");
      MarkClean();
    }
 
    protected void MarkDeleted()
    {
      _isDeleted = true;
      MetaPropertyHasChanged("IsDeleted");
      MarkDirty();
    }
 
    protected void MarkDirty()
    {
      MarkDirty(false);
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected void MarkDirty(bool suppressEvent)
    {
      bool old = _isDirty;
      _isDirty = true;
      if (!suppressEvent)
        OnUnknownPropertyChanged();
      if (_isDirty != old)
      {
        MetaPropertyHasChanged("IsSelfDirty");
        MetaPropertyHasChanged("IsDirty");
        MetaPropertyHasChanged("IsSavable");
      }
    }
 
    protected virtual void PropertyHasChanged(Csla.Core.IPropertyInfo property)
    {
      MarkDirty(true);
      CheckPropertyRules(property);
    }
 
    private void PropertyHasChanged(string propertyName)
    {
      PropertyHasChanged(FieldManager.GetRegisteredProperty(propertyName));
    }
 
    protected virtual void MetaPropertyHasChanged(string name)
    {
      if (ApplicationContext.PropertyChangedMode != ApplicationContext.PropertyChangedModes.Windows)
        OnMetaPropertyChanged(name);
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void CheckPropertyRules(IPropertyInfo property)
    {
      var propertyNames = BusinessRules.CheckRules(property);
      if (ApplicationContext.PropertyChangedMode == ApplicationContext.PropertyChangedModes.Windows)
        OnPropertyChanged(property);
      else
        foreach (var name in propertyNames)
          OnPropertyChanged(name);
    }
 
    protected virtual void CheckObjectRules()
    {
      var propertyNames = BusinessRules.CheckObjectRules();
      if (ApplicationContext.PropertyChangedMode == ApplicationContext.PropertyChangedModes.Windows)
      {
        OnUnknownPropertyChanged();
      }
      else
        foreach (var name in propertyNames)
          OnPropertyChanged(name);
    }
 
 
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected void MarkClean()
    {
      _isDirty = false;
      if (_fieldManager != null)
        FieldManager.MarkClean();
      OnUnknownPropertyChanged();
      MetaPropertyHasChanged("IsSelfDirty");
      MetaPropertyHasChanged("IsDirty");
      MetaPropertyHasChanged("IsSavable");
    }
 
    [Browsable(false)]
    [Display(AutoGenerateField = false)]
    [ScaffoldColumn(false)]
    public virtual bool IsSavable
    {
      get
      {
        bool auth;
        if (IsDeleted)
          auth = Csla.Rules.BusinessRules.HasPermission(ApplicationContext, Rules.AuthorizationActions.DeleteObject, this);
        else if (IsNew)
          auth = Csla.Rules.BusinessRules.HasPermission(ApplicationContext, Rules.AuthorizationActions.CreateObject, this);
        else
          auth = Csla.Rules.BusinessRules.HasPermission(ApplicationContext, Rules.AuthorizationActions.EditObject, this);
        return (auth && IsDirty && IsValid && !IsBusy);
      }
    }
 
    #endregion
 
    #region Authorization
 
    [NotUndoable]
    [NonSerialized]
    private ConcurrentDictionary<string, bool> _readResultCache;
    [NotUndoable]
    [NonSerialized]
    private ConcurrentDictionary<string, bool> _writeResultCache;
    [NotUndoable]
    [NonSerialized]
    private ConcurrentDictionary<string, bool> _executeResultCache;
    [NotUndoable]
    [NonSerialized]
    private System.Security.Principal.IPrincipal _lastPrincipal;
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public virtual bool CanReadProperty(Csla.Core.IPropertyInfo property)
    {
      var result = true;
 
      VerifyAuthorizationCache();
 
      if (!_readResultCache.TryGetValue(property.Name, out result))
      {
        result = BusinessRules.HasPermission(ApplicationContext, AuthorizationActions.ReadProperty, property);
        if (BusinessRules.CachePermissionResult(AuthorizationActions.ReadProperty, property))
        {
          // store value in cache
          _readResultCache.AddOrUpdate(property.Name, result, (a,b) => { return result; });
        }
      }
      return result;
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public bool CanReadProperty(Csla.Core.IPropertyInfo property, bool throwOnFalse)
    {
      bool result = CanReadProperty(property);
      if (throwOnFalse && result == false)
      {
        Csla.Security.SecurityException ex = new Csla.Security.SecurityException(
          String.Format("{0} ({1})",
          Resources.PropertyGetNotAllowed, property.Name));
        throw ex;
      }
      return result;
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public bool CanReadProperty(string propertyName)
    {
      return CanReadProperty(propertyName, false);
    }
 
    private bool CanReadProperty(string propertyName, bool throwOnFalse)
    {
      var propertyInfo = FieldManager.GetRegisteredProperties().FirstOrDefault(p => p.Name == propertyName);
      if (propertyInfo == null)
      {
        Trace.TraceError("CanReadProperty: {0} is not a registered property of {1}.{2}", propertyName, this.GetType().Namespace, this.GetType().Name);
        return true;
      }
      return CanReadProperty(propertyInfo, throwOnFalse);
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public virtual bool CanWriteProperty(Csla.Core.IPropertyInfo property)
    {
      bool result = true;
 
      VerifyAuthorizationCache();
 
      if (!_writeResultCache.TryGetValue(property.Name, out result))
      {
        result = BusinessRules.HasPermission(ApplicationContext, AuthorizationActions.WriteProperty, property);
        if (BusinessRules.CachePermissionResult(AuthorizationActions.WriteProperty, property))
        {
          // store value in cache
          _writeResultCache.AddOrUpdate(property.Name, result, (a, b) => { return result; });
        }
      }
      return result;
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public bool CanWriteProperty(Csla.Core.IPropertyInfo property, bool throwOnFalse)
    {
      bool result = CanWriteProperty(property);
      if (throwOnFalse && result == false)
      {
        Csla.Security.SecurityException ex = new Csla.Security.SecurityException(
          String.Format("{0} ({1})", Resources.PropertySetNotAllowed, property.Name));
        throw ex;
      }
      return result;
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public bool CanWriteProperty(string propertyName)
    {
      return CanWriteProperty(propertyName, false);
    }
 
    private bool CanWriteProperty(string propertyName, bool throwOnFalse)
    {
      var propertyInfo = FieldManager.GetRegisteredProperties().FirstOrDefault(p => p.Name == propertyName);
      if (propertyInfo == null)
      {
        Trace.TraceError("CanReadProperty: {0} is not a registered property of {1}.{2}", propertyName, this.GetType().Namespace, this.GetType().Name);
        return true;
      }
      return CanWriteProperty(propertyInfo, throwOnFalse);
    }
 
    private void VerifyAuthorizationCache()
    {
      if (_readResultCache == null)
        _readResultCache = new ConcurrentDictionary<string, bool>();
      if (_writeResultCache == null)
        _writeResultCache = new ConcurrentDictionary<string, bool>();
      if (_executeResultCache == null)
        _executeResultCache = new ConcurrentDictionary<string, bool>();
      if (!ReferenceEquals(ApplicationContext.User, _lastPrincipal))
      {
        // the principal has changed - reset the cache
        _readResultCache.Clear();
        _writeResultCache.Clear();
        _executeResultCache.Clear();
        _lastPrincipal = ApplicationContext.User;
      }
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public virtual bool CanExecuteMethod(Csla.Core.IMemberInfo method)
    {
      bool result = true;
 
      VerifyAuthorizationCache();
 
      if (!_executeResultCache.TryGetValue(method.Name, out result))
      {
        result = BusinessRules.HasPermission(ApplicationContext, AuthorizationActions.ExecuteMethod, method);
        if (BusinessRules.CachePermissionResult(AuthorizationActions.ExecuteMethod, method))
        {
          // store value in cache
          _executeResultCache.AddOrUpdate(method.Name, result, (a, b) => { return result; });
        }
      }
      return result;
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public bool CanExecuteMethod(Csla.Core.IMemberInfo method, bool throwOnFalse)
    {
 
      bool result = CanExecuteMethod(method);
      if (throwOnFalse && result == false)
      {
        Csla.Security.SecurityException ex =
          new Csla.Security.SecurityException(string.Format("{0} ({1})", Properties.Resources.MethodExecuteNotAllowed, method.Name));
        throw ex;
      }
      return result;
 
    }
 
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public virtual bool CanExecuteMethod(string methodName)
    {
      return CanExecuteMethod(methodName, false);
    }
 
    private bool CanExecuteMethod(string methodName, bool throwOnFalse)
    {
 
      bool result = CanExecuteMethod(new MethodInfo(methodName));
      if (throwOnFalse && result == false)
      {
        Csla.Security.SecurityException ex = new Csla.Security.SecurityException(string.Format("{0} ({1})", Properties.Resources.MethodExecuteNotAllowed, methodName));
        throw ex;
      }
      return result;
    }
 
#endregion
 
#region System.ComponentModel.IEditableObject
 
    private bool _neverCommitted = true;
    [NotUndoable]
    private bool _disableIEditableObject;
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected bool DisableIEditableObject
    {
      get
      {
        return _disableIEditableObject;
      }
      set
      {
        _disableIEditableObject = value;
      }
    }
 
    void System.ComponentModel.IEditableObject.BeginEdit()
    {
      if (!_disableIEditableObject && !BindingEdit)
      {
        BindingEdit = true;
        BeginEdit();
      }
    }
 
    void System.ComponentModel.IEditableObject.CancelEdit()
    {
      if (!_disableIEditableObject && BindingEdit)
      {
        CancelEdit();
        BindingEdit = false;
        if (IsNew && _neverCommitted && EditLevel <= EditLevelAdded)
        {
          // we're new and no EndEdit or ApplyEdit has ever been
          // called on us, and now we've been cancelled back to
          // where we were added so we should have ourselves
          // removed from the parent collection
          if (Parent != null)
            Parent.RemoveChild(this);
        }
      }
    }
 
    void System.ComponentModel.IEditableObject.EndEdit()
    {
      if (!_disableIEditableObject && BindingEdit)
      {
        ApplyEdit();
        BindingEdit = false;
      }
    }
 
#endregion
 
#region Begin/Cancel/ApplyEdit
 
    public void BeginEdit()
    {
      CopyState(this.EditLevel + 1);
    }
 
    public void CancelEdit()
    {
      UndoChanges(this.EditLevel - 1);
    }
 
    protected override void UndoChangesComplete()
    {
      BusinessRules.SetTarget(this);
      InitializeBusinessRules();
      OnUnknownPropertyChanged();
      base.UndoChangesComplete();
    }
 
    public void ApplyEdit()
    {
      _neverCommitted = false;
      AcceptChanges(this.EditLevel - 1);
      //Next line moved to IEditableObject.ApplyEdit 
      //BindingEdit = false;
    }
 
    protected override void AcceptChangesComplete()
    {
      BindingEdit = false;
      base.AcceptChangesComplete();
 
      // !!!! Will trigger Save here when using DynamicListBase template
      if (Parent != null)
        Parent.ApplyEditChild(this);
    }
 
#endregion
 
#region IsChild
 
    [NotUndoable]
    private bool _isChild;
 
    [Browsable(false)]
    [Display(AutoGenerateField = false)]
    [ScaffoldColumn(false)]
    public bool IsChild
    {
      get { return _isChild; }
    }
 
    protected void MarkAsChild()
    {
      _identity = -1;
      _isChild = true;
    }
 
#endregion
 
#region Delete
 
    public virtual void Delete()
    {
      if (this.IsChild)
        throw new NotSupportedException(Resources.ChildDeleteException);
 
      MarkDeleted();
    }
 
    internal void DeleteChild()
    {
      if (!this.IsChild)
        throw new NotSupportedException(Resources.NoDeleteRootException);
 
      BindingEdit = false;
      MarkDeleted();
    }
 
#endregion
 
#region Edit Level Tracking (child only)
 
    // we need to keep track of the edit
    // level when we weere added so if the user
    // cancels below that level we can be destroyed
    [NotUndoable]
    private int _editLevelAdded;
 
    internal int EditLevelAdded
    {
      get { return _editLevelAdded; }
      set { _editLevelAdded = value; }
    }
 
    int IUndoableObject.EditLevel
    {
      get
      {
        return this.EditLevel;
      }
    }
 
#endregion
 
#region ICloneable
 
    object ICloneable.Clone()
    {
      return GetClone();
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual object GetClone()
    {
      return Core.ObjectCloner.GetInstance(ApplicationContext).Clone(this);
    }
 
#endregion
 
#region BusinessRules, IsValid
 
    [NonSerialized]
    [NotUndoable]
    private EventHandler _validationCompleteHandlers;
 
    public event EventHandler ValidationComplete
    {
      add
      {
        _validationCompleteHandlers = (EventHandler)
          System.Delegate.Combine(_validationCompleteHandlers, value);
      }
      remove
      {
        _validationCompleteHandlers = (EventHandler)
          System.Delegate.Remove(_validationCompleteHandlers, value);
      }
    }
 
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected virtual void OnValidationComplete()
    {
      if (_validationCompleteHandlers != null)
        _validationCompleteHandlers(this, EventArgs.Empty);
    }
 
    private void InitializeBusinessRules()
    {
      var rules = BusinessRuleManager.GetRulesForType(this.GetType());
      if (!rules.Initialized)
        lock (rules)
          if (!rules.Initialized)
          {
            try
            {
              AddBusinessRules();
              rules.Initialized = true;
            }
            catch (Exception)
            {
              BusinessRuleManager.CleanupRulesForType(this.GetType());
              throw;  // and rethrow exception
            }
          }
    }
 
    private Csla.Rules.BusinessRules _businessRules;
 
    protected BusinessRules BusinessRules
    {
      get
      {
        if (_businessRules == null)
          _businessRules = new BusinessRules(ApplicationContext, this);
        else if (_businessRules.Target == null)
          _businessRules.SetTarget(this);
        return _businessRules;
      }
    }
 
    BusinessRules IUseBusinessRules.BusinessRules => BusinessRules;
 
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected BusinessRuleManager GetRegisteredRules()
    {
      return BusinessRules.TypeRules;
    }
 
    void IHostRules.RuleStart(IPropertyInfo property)
    {
      OnBusyChanged(new BusyChangedEventArgs(property.Name, true));
    }
 
    void IHostRules.RuleComplete(IPropertyInfo property)
    {
      OnPropertyChanged(property);
      OnBusyChanged(new BusyChangedEventArgs(property.Name, false));
      MetaPropertyHasChanged("IsSelfValid");
      MetaPropertyHasChanged("IsValid");
      MetaPropertyHasChanged("IsSavable");
    }
 
    void IHostRules.RuleComplete(string property)
    {
      OnPropertyChanged(property);
      MetaPropertyHasChanged("IsSelfValid");
      MetaPropertyHasChanged("IsValid");
      MetaPropertyHasChanged("IsSavable");
    }
 
    void Rules.IHostRules.AllRulesComplete()
    {
      OnValidationComplete();
      MetaPropertyHasChanged("IsSelfValid");
      MetaPropertyHasChanged("IsValid");
      MetaPropertyHasChanged("IsSavable");
    }
 
    protected virtual void AddBusinessRules()
    {
      BusinessRules.AddDataAnnotations();
    }
 
    [Browsable(false)]
    [Display(AutoGenerateField = false)]
    [ScaffoldColumn(false)]
    public virtual bool IsValid
    {
      get { return IsSelfValid && (_fieldManager == null || FieldManager.IsValid()); }
    }
 
    [Browsable(false)]
    [Display(AutoGenerateField = false)]
    [ScaffoldColumn(false)]
    public virtual bool IsSelfValid
    {
      get { return BusinessRules.IsValid; }
    }
 
    [Browsable(false)]
    [Display(AutoGenerateField = false)]
    [ScaffoldColumn(false)]
    [System.ComponentModel.DataAnnotations.Schema.NotMapped]
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public virtual Rules.BrokenRulesCollection BrokenRulesCollection
    {
      get { return BusinessRules.GetBrokenRules(); }
    }
 
#endregion
 
#region Data Access
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void DataPortal_OnDataPortalInvoke(DataPortalEventArgs e)
    { }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void DataPortal_OnDataPortalInvokeComplete(DataPortalEventArgs e)
    { }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void DataPortal_OnDataPortalException(DataPortalEventArgs e, Exception ex)
    { }
 
    protected virtual void Child_Create()
    {
      BusinessRules.CheckRules();
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void Child_OnDataPortalInvoke(DataPortalEventArgs e)
    { }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void Child_OnDataPortalInvokeComplete(DataPortalEventArgs e)
    { }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void Child_OnDataPortalException(DataPortalEventArgs e, Exception ex)
    { }
 
#endregion
 
    #region IDataErrorInfo
 
    string IDataErrorInfo.Error
    {
      get
      {
        if (!IsSelfValid)
          return BusinessRules.GetBrokenRules().ToString(
            Csla.Rules.RuleSeverity.Error);
        else
          return String.Empty;
      }
    }
 
    IEnumerable INotifyDataErrorInfo.GetErrors(string propertyName)
    {
      return BusinessRules.GetBrokenRules().Select(r => r.Description);
    }
 
    bool INotifyDataErrorInfo.HasErrors => !IsSelfValid;
 
    string IDataErrorInfo.this[string columnName]
    {
      get
      {
        string result = string.Empty;
        if (!IsSelfValid)
        {
          Rules.BrokenRule rule =
            BusinessRules.GetBrokenRules().GetFirstBrokenRule(columnName);
          if (rule != null)
            result = rule.Description;
        }
        return result;
      }
    }
 
    [NonSerialized]
    [NotUndoable]
    private EventHandler<DataErrorsChangedEventArgs> _errorsChanged;
 
    event EventHandler<DataErrorsChangedEventArgs> INotifyDataErrorInfo.ErrorsChanged
    {
      add
      {
        _errorsChanged = (EventHandler<DataErrorsChangedEventArgs>)
          System.Delegate.Combine(_errorsChanged, value);
      }
      remove
      {
        _errorsChanged = (EventHandler<DataErrorsChangedEventArgs>)
          System.Delegate.Remove(_errorsChanged, value);
      }
    }
 
    protected virtual void OnErrorsChanged(string propertyName)
    {
      _errorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected override void OnPropertyChanged(IPropertyInfo propertyInfo)
    {
      base.OnPropertyChanged(propertyInfo);
      OnErrorsChanged(propertyInfo.Name);
    }
 
    #endregion
 
    #region Serialization Notification
 
    void ISerializationNotification.Deserialized()
    {
      OnDeserializedHandler(new System.Runtime.Serialization.StreamingContext());
    }
 
    [System.Runtime.Serialization.OnDeserialized]
    private void OnDeserializedHandler(System.Runtime.Serialization.StreamingContext context)
    {
      BusinessRules.SetTarget(this);
      if (_fieldManager != null)
        FieldManager.SetPropertyList(this.GetType());
      InitializeBusinessRules();
      FieldDataDeserialized();
 
      OnDeserialized(context);
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void OnDeserialized(System.Runtime.Serialization.StreamingContext context)
    { }
 
#endregion
 
#region Bubbling event Hooks
 
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected void AddEventHooks(IBusinessObject child)
    {
      OnAddEventHooks(child);
    }
 
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected virtual void OnAddEventHooks(IBusinessObject child)
    {
      INotifyBusy busy = child as INotifyBusy;
      if (busy != null)
        busy.BusyChanged += Child_BusyChanged;
 
      INotifyUnhandledAsyncException unhandled = child as INotifyUnhandledAsyncException;
      if (unhandled != null)
        unhandled.UnhandledAsyncException += Child_UnhandledAsyncException;
 
      INotifyPropertyChanged pc = child as INotifyPropertyChanged;
      if (pc != null)
        pc.PropertyChanged += Child_PropertyChanged;
 
      IBindingList bl = child as IBindingList;
      if (bl != null)
        bl.ListChanged += Child_ListChanged;
 
      INotifyCollectionChanged ncc = child as INotifyCollectionChanged;
      if (ncc != null)
        ncc.CollectionChanged += Child_CollectionChanged;
 
      INotifyChildChanged cc = child as INotifyChildChanged;
      if (cc != null)
        cc.ChildChanged += Child_Changed;
    }
 
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected void RemoveEventHooks(IBusinessObject child)
    {
      OnRemoveEventHooks(child);
    }
 
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected virtual void OnRemoveEventHooks(IBusinessObject child)
    {
      INotifyBusy busy = child as INotifyBusy;
      if (busy != null)
        busy.BusyChanged -= Child_BusyChanged;
 
      INotifyUnhandledAsyncException unhandled = child as INotifyUnhandledAsyncException;
      if (unhandled != null)
        unhandled.UnhandledAsyncException -= Child_UnhandledAsyncException;
 
      INotifyPropertyChanged pc = child as INotifyPropertyChanged;
      if (pc != null)
        pc.PropertyChanged -= Child_PropertyChanged;
 
      IBindingList bl = child as IBindingList;
      if (bl != null)
        bl.ListChanged -= Child_ListChanged;
 
      INotifyCollectionChanged ncc = child as INotifyCollectionChanged;
      if (ncc != null)
        ncc.CollectionChanged -= Child_CollectionChanged;
 
      INotifyChildChanged cc = child as INotifyChildChanged;
      if (cc != null)
        cc.ChildChanged -= Child_Changed;
    }
 
#endregion
 
#region Busy / Unhandled exception bubbling
 
    private void Child_UnhandledAsyncException(object sender, ErrorEventArgs e)
    {
      OnUnhandledAsyncException(e);
    }
 
    private void Child_BusyChanged(object sender, BusyChangedEventArgs e)
    {
      OnBusyChanged(e);
    }
 
#endregion
 
#region IEditableBusinessObject Members
 
    int IEditableBusinessObject.EditLevelAdded
    {
      get
      {
        return this.EditLevelAdded;
      }
      set
      {
        this.EditLevelAdded = value;
      }
    }
 
    void IEditableBusinessObject.DeleteChild()
    {
      this.DeleteChild();
    }
 
    void IEditableBusinessObject.SetParent(IParent parent)
    {
      this.SetParent(parent);
    }
 
#endregion
 
#region Register Methods
 
    protected static Csla.Core.IMemberInfo RegisterMethod(Type objectType, IMemberInfo info)
    {
      var reflected = objectType.GetMethod(info.Name);
      if (reflected == null)
        throw new ArgumentException(string.Format(Resources.NoSuchMethod, info.Name), "info");
      return info;
    }
 
    protected static MethodInfo RegisterMethod(Type objectType, string methodName)
    {
      var info = new MethodInfo(methodName);
      RegisterMethod(objectType, info);
      return info;
    }
 
#endregion
 
#region  Register Properties
 
    protected static PropertyInfo<P> RegisterProperty<P>(Type objectType, PropertyInfo<P> info)
    {
      return Core.FieldManager.PropertyInfoManager.RegisterProperty<P>(objectType, info);
    }
 
#endregion
 
#region  Get Properties
 
    protected P GetProperty<P>(string propertyName, P field, P defaultValue)
    {
      return GetProperty<P>(propertyName, field, defaultValue, Security.NoAccessBehavior.SuppressException);
    }
 
    protected P GetProperty<P>(string propertyName, P field, P defaultValue, Security.NoAccessBehavior noAccess)
    {
#region Check to see if the property is marked with RelationshipTypes.PrivateField
 
      var propertyInfo = FieldManager.GetRegisteredProperty(propertyName);
 
      if ((propertyInfo.RelationshipType & RelationshipTypes.PrivateField) != RelationshipTypes.PrivateField)
        throw new InvalidOperationException(Resources.PrivateFieldException);
 
#endregion
 
      if (_bypassPropertyChecks || CanReadProperty(propertyInfo, noAccess == Security.NoAccessBehavior.ThrowException))
        return field;
 
      return defaultValue;
    }
 
    protected P GetProperty<P>(PropertyInfo<P> propertyInfo, P field)
    {
      return GetProperty<P>(propertyInfo.Name, field, propertyInfo.DefaultValue, Security.NoAccessBehavior.SuppressException);
    }
 
    protected P GetProperty<P>(PropertyInfo<P> propertyInfo, P field, P defaultValue, Security.NoAccessBehavior noAccess)
    {
      return GetProperty<P>(propertyInfo.Name, field, defaultValue, noAccess);
    }
 
    protected P GetPropertyConvert<F, P>(PropertyInfo<F> propertyInfo, F field)
    {
      return Utilities.CoerceValue<P>(typeof(F), null, GetProperty<F>(propertyInfo.Name, field, propertyInfo.DefaultValue, Security.NoAccessBehavior.SuppressException));
    }
 
    protected P GetPropertyConvert<F, P>(PropertyInfo<F> propertyInfo, F field, Security.NoAccessBehavior noAccess)
    {
      return Utilities.CoerceValue<P>(typeof(F), null, GetProperty<F>(propertyInfo.Name, field, propertyInfo.DefaultValue, noAccess));
    }
 
    protected P GetProperty<P>(PropertyInfo<P> propertyInfo)
    {
      return GetProperty<P>(propertyInfo, Security.NoAccessBehavior.SuppressException);
    }
 
    protected P GetPropertyConvert<F, P>(PropertyInfo<F> propertyInfo)
    {
      return Utilities.CoerceValue<P>(typeof(F), null, GetProperty<F>(propertyInfo, Security.NoAccessBehavior.SuppressException));
    }
 
    protected P GetPropertyConvert<F, P>(PropertyInfo<F> propertyInfo, Security.NoAccessBehavior noAccess)
    {
      return Utilities.CoerceValue<P>(typeof(F), null, GetProperty<F>(propertyInfo, noAccess));
    }
 
    protected P GetProperty<P>(PropertyInfo<P> propertyInfo, Security.NoAccessBehavior noAccess)
    {
      if (((propertyInfo.RelationshipType & RelationshipTypes.LazyLoad) == RelationshipTypes.LazyLoad) && !FieldManager.FieldExists(propertyInfo))
      {
        if (PropertyIsLoading(propertyInfo))
          return propertyInfo.DefaultValue;
        throw new InvalidOperationException(Resources.PropertyGetNotAllowed);
      }
 
      P result = default;
      if (_bypassPropertyChecks || CanReadProperty(propertyInfo, noAccess == Csla.Security.NoAccessBehavior.ThrowException))
        result = ReadProperty<P>(propertyInfo);
      else
        result = propertyInfo.DefaultValue;
      return result;
    }
 
    protected object GetProperty(IPropertyInfo propertyInfo)
    {
      object result;
      if (_bypassPropertyChecks || CanReadProperty(propertyInfo, false))
      {
        // call ReadProperty (may be overloaded in actual class)
        result = ReadProperty(propertyInfo);
      }
      else
      {
        result = propertyInfo.DefaultValue;
      }
      return result;
    }
 
    protected P GetProperty<P>(IPropertyInfo propertyInfo)
    {
      return (P)GetProperty(propertyInfo);
    }
 
    protected P LazyGetProperty<P>(PropertyInfo<P> property, Func<P> valueGenerator)
    {
      if (!(FieldManager.FieldExists(property)))
      {
        var result = valueGenerator();
        LoadProperty(property, result);
      }
      return GetProperty<P>(property);
    }
 
    protected bool PropertyIsLoading(IPropertyInfo propertyInfo)
    {
      return LoadManager.IsLoadingProperty(propertyInfo);
    }
 
    protected P LazyGetPropertyAsync<P>(PropertyInfo<P> property, Task<P> factory)
    {
      if (!(FieldManager.FieldExists(property)) && !PropertyIsLoading(property))
      {
        LoadPropertyAsync(property, factory);
      }
      return GetProperty<P>(property);
    }
 
    object IManageProperties.LazyGetProperty<P>(PropertyInfo<P> propertyInfo, Func<P> valueGenerator)
    {
      return LazyGetProperty(propertyInfo, valueGenerator);
    }
 
    object IManageProperties.LazyGetPropertyAsync<P>(PropertyInfo<P> propertyInfo, Task<P> factory)
    {
      return LazyGetPropertyAsync(propertyInfo, factory);
    }
 
#endregion
 
#region  Read Properties
 
    protected P ReadPropertyConvert<F, P>(PropertyInfo<F> propertyInfo)
    {
      return Utilities.CoerceValue<P>(typeof(F), null, ReadProperty<F>(propertyInfo));
    }
 
    protected P ReadProperty<P>(PropertyInfo<P> propertyInfo)
    {
      if (((propertyInfo.RelationshipType & RelationshipTypes.LazyLoad) == RelationshipTypes.LazyLoad) && !FieldManager.FieldExists(propertyInfo))
      {
        if (PropertyIsLoading(propertyInfo))
          return default;
        throw new InvalidOperationException(Resources.PropertyGetNotAllowed);
      }
 
      P result = default;
      FieldManager.IFieldData data = FieldManager.GetFieldData(propertyInfo);
      if (data != null)
      {
        FieldManager.IFieldData<P> fd = data as FieldManager.IFieldData<P>;
        if (fd != null)
          result = fd.Value;
        else
          result = (P)data.Value;
      }
      else
      {
        result = propertyInfo.DefaultValue;
        FieldManager.LoadFieldData<P>(propertyInfo, result);
      }
      return result;
    }
 
    protected virtual object ReadProperty(IPropertyInfo propertyInfo)
    {
      if (((propertyInfo.RelationshipType & RelationshipTypes.LazyLoad) == RelationshipTypes.LazyLoad) && !FieldManager.FieldExists(propertyInfo))
        throw new InvalidOperationException(Resources.PropertyGetNotAllowed);
 
      if ((propertyInfo.RelationshipType & RelationshipTypes.PrivateField) == RelationshipTypes.PrivateField)
      {
        using (BypassPropertyChecks)
        {
          return MethodCaller.CallPropertyGetter(this, propertyInfo.Name);
        }
      }
 
      object result = null;
      var info = FieldManager.GetFieldData(propertyInfo);
      if (info != null)
      {
        result = info.Value;
      }
      else
      {
        result = propertyInfo.DefaultValue;
        FieldManager.LoadFieldData(propertyInfo, result);
      }
 
      return result;
    }
 
    protected P LazyReadProperty<P>(PropertyInfo<P> property, Func<P> valueGenerator)
    {
      if (!(FieldManager.FieldExists(property)))
      {
        var result = valueGenerator();
        LoadProperty(property, result);
      }
      return ReadProperty<P>(property);
    }
 
    protected P LazyReadPropertyAsync<P>(PropertyInfo<P> property, Task<P> factory)
    {
      if (!(FieldManager.FieldExists(property)) && !PropertyIsLoading(property))
      {
        LoadPropertyAsync(property, factory);
      }
      return ReadProperty<P>(property);
    }
 
    P IManageProperties.LazyReadProperty<P>(PropertyInfo<P> propertyInfo, Func<P> valueGenerator)
    {
      return LazyReadProperty(propertyInfo, valueGenerator);
    }
 
    P IManageProperties.LazyReadPropertyAsync<P>(PropertyInfo<P> propertyInfo, Task<P> factory)
    {
      return LazyReadPropertyAsync(propertyInfo, factory);
    }
 
#endregion
 
#region  Set Properties
 
    protected void SetProperty<P>(PropertyInfo<P> propertyInfo, ref P field, P newValue)
    {
      SetProperty<P>(propertyInfo.Name, ref field, newValue, Security.NoAccessBehavior.ThrowException);
    }
 
    protected void SetProperty<P>(string propertyName, ref P field, P newValue)
    {
      SetProperty<P>(propertyName, ref field, newValue, Security.NoAccessBehavior.ThrowException);
    }
 
    protected void SetPropertyConvert<P, V>(PropertyInfo<P> propertyInfo, ref P field, V newValue)
    {
      SetPropertyConvert<P, V>(propertyInfo, ref field, newValue, Security.NoAccessBehavior.ThrowException);
    }
 
    protected void SetPropertyConvert<P, V>(PropertyInfo<P> propertyInfo, ref P field, V newValue, Security.NoAccessBehavior noAccess)
    {
      SetPropertyConvert<P, V>(propertyInfo.Name, ref field, newValue, noAccess);
    }
 
    protected void SetProperty<P>(string propertyName, ref P field, P newValue, Security.NoAccessBehavior noAccess)
    {
      try
      {
#region Check to see if the property is marked with RelationshipTypes.PrivateField
 
        var propertyInfo = FieldManager.GetRegisteredProperty(propertyName);
 
        if ((propertyInfo.RelationshipType & RelationshipTypes.PrivateField) != RelationshipTypes.PrivateField)
          throw new InvalidOperationException(Resources.PrivateFieldException);
 
#endregion
 
        if (_bypassPropertyChecks || CanWriteProperty(propertyInfo, noAccess == Security.NoAccessBehavior.ThrowException))
        {
          bool doChange = false;
          if (field == null)
          {
            if (newValue != null)
              doChange = true;
          }
          else
          {
            if (typeof(P) == typeof(string) && newValue == null)
              newValue = Utilities.CoerceValue<P>(typeof(string), field, string.Empty);
            if (!field.Equals(newValue))
              doChange = true;
          }
          if (doChange)
          {
            if (!_bypassPropertyChecks) OnPropertyChanging(propertyName);
            field = newValue;
            if (!_bypassPropertyChecks) PropertyHasChanged(propertyName);
          }
        }
      }
      catch (System.Security.SecurityException ex)
      {
        throw new Csla.Security.SecurityException(ex.Message);
      }
      catch (Csla.Security.SecurityException)
      {
        throw;
      }
      catch (Exception ex)
      {
        throw new PropertyLoadException(
          string.Format(Resources.PropertyLoadException, propertyName, ex.Message, ex.Message), ex);
      }
    }
 
    protected void SetPropertyConvert<P, V>(string propertyName, ref P field, V newValue, Security.NoAccessBehavior noAccess)
    {
      try
      {
#region Check to see if the property is marked with RelationshipTypes.PrivateField
 
        var propertyInfo = FieldManager.GetRegisteredProperty(propertyName);
 
        if ((propertyInfo.RelationshipType & RelationshipTypes.PrivateField) != RelationshipTypes.PrivateField)
          throw new InvalidOperationException(Resources.PrivateFieldException);
 
#endregion
 
        if (_bypassPropertyChecks || CanWriteProperty(propertyInfo, noAccess == Security.NoAccessBehavior.ThrowException))
        {
          bool doChange = false;
          if (field == null)
          {
            if (newValue != null)
              doChange = true;
          }
          else
          {
            if (typeof(V) == typeof(string) && newValue == null)
              newValue = Utilities.CoerceValue<V>(typeof(string), null, string.Empty);
            if (!field.Equals(newValue))
              doChange = true;
          }
          if (doChange)
          {
            if (!_bypassPropertyChecks) OnPropertyChanging(propertyName);
            field = Utilities.CoerceValue<P>(typeof(V), field, newValue);
            if (!_bypassPropertyChecks) PropertyHasChanged(propertyName);
          }
        }
      }
      catch (System.Security.SecurityException ex)
      {
        throw new Csla.Security.SecurityException(ex.Message);
      }
      catch (Csla.Security.SecurityException)
      {
        throw;
      }
      catch (Exception ex)
      {
        throw new PropertyLoadException(
          string.Format(Properties.Resources.PropertyLoadException, propertyName, ex.Message), ex);
      }
    }
 
    protected void SetProperty<P>(PropertyInfo<P> propertyInfo, P newValue)
    {
      SetProperty<P>(propertyInfo, newValue, Security.NoAccessBehavior.ThrowException);
    }
 
    protected void SetPropertyConvert<P, F>(PropertyInfo<P> propertyInfo, F newValue)
    {
      SetPropertyConvert<P, F>(propertyInfo, newValue, Security.NoAccessBehavior.ThrowException);
    }
 
    protected void SetPropertyConvert<P, F>(PropertyInfo<P> propertyInfo, F newValue, Security.NoAccessBehavior noAccess)
    {
      try
      {
        if (_bypassPropertyChecks || CanWriteProperty(propertyInfo, noAccess == Security.NoAccessBehavior.ThrowException))
        {
          P oldValue = default(P);
          var fieldData = FieldManager.GetFieldData(propertyInfo);
          if (fieldData == null)
          {
            oldValue = propertyInfo.DefaultValue;
            fieldData = FieldManager.LoadFieldData<P>(propertyInfo, oldValue);
          }
          else
          {
            var fd = fieldData as FieldManager.IFieldData<P>;
            if (fd != null)
              oldValue = fd.Value;
            else
              oldValue = (P)fieldData.Value;
          }
          if (typeof(F) == typeof(string) && newValue == null)
            newValue = Utilities.CoerceValue<F>(typeof(string), null, string.Empty);
          LoadPropertyValue<P>(propertyInfo, oldValue, Utilities.CoerceValue<P>(typeof(F), oldValue, newValue), !_bypassPropertyChecks);
        }
      }
      catch (System.Security.SecurityException ex)
      {
        throw new Csla.Security.SecurityException(ex.Message);
      }
      catch (Csla.Security.SecurityException)
      {
        throw;
      }
      catch (Exception ex)
      {
        throw new PropertyLoadException(
          string.Format(Properties.Resources.PropertyLoadException, propertyInfo.Name, ex.Message), ex);
      }
    }
 
    protected void SetProperty<P>(PropertyInfo<P> propertyInfo, P newValue, Security.NoAccessBehavior noAccess)
    {
      if (_bypassPropertyChecks || CanWriteProperty(propertyInfo, noAccess == Security.NoAccessBehavior.ThrowException))
      {
        try
        {
          P oldValue = default(P);
          var fieldData = FieldManager.GetFieldData(propertyInfo);
          if (fieldData == null)
          {
            oldValue = propertyInfo.DefaultValue;
            fieldData = FieldManager.LoadFieldData<P>(propertyInfo, oldValue);
          }
          else
          {
            var fd = fieldData as FieldManager.IFieldData<P>;
            if (fd != null)
              oldValue = fd.Value;
            else
              oldValue = (P)fieldData.Value;
          }
          if (typeof(P) == typeof(string) && newValue == null)
            newValue = Utilities.CoerceValue<P>(typeof(string), null, string.Empty);
          LoadPropertyValue<P>(propertyInfo, oldValue, newValue, !_bypassPropertyChecks);
        }
        catch (Exception ex)
        {
          throw new PropertyLoadException(
            string.Format(Properties.Resources.PropertyLoadException, propertyInfo.Name, ex.Message), ex);
        }
      }
    }
 
    protected void SetProperty(IPropertyInfo propertyInfo, object newValue)
    {
      try
      {
        if (_bypassPropertyChecks || CanWriteProperty(propertyInfo, true))
        {
          if (!_bypassPropertyChecks) OnPropertyChanging(propertyInfo);
          FieldManager.SetFieldData(propertyInfo, newValue);
          if (!_bypassPropertyChecks) PropertyHasChanged(propertyInfo);
        }
      }
      catch (System.Security.SecurityException ex)
      {
        throw new Csla.Security.SecurityException(ex.Message);
      }
      catch (Csla.Security.SecurityException)
      {
        throw;
      }
      catch (Exception ex)
      {
        throw new PropertyLoadException(
          string.Format(Resources.PropertyLoadException, propertyInfo.Name, ex.Message), ex);
      }
    }
 
    protected void SetProperty<P>(IPropertyInfo propertyInfo, P newValue)
    {
      SetProperty(propertyInfo, (object)newValue);
    }
 
#endregion
 
#region  Load Properties
 
    protected void LoadPropertyConvert<P, F>(PropertyInfo<P> propertyInfo, F newValue)
    {
      try
      {
        P oldValue = default(P);
        var fieldData = FieldManager.GetFieldData(propertyInfo);
        if (fieldData == null)
        {
          oldValue = propertyInfo.DefaultValue;
          fieldData = FieldManager.LoadFieldData<P>(propertyInfo, oldValue);
        }
        else
        {
          var fd = fieldData as FieldManager.IFieldData<P>;
          if (fd != null)
            oldValue = fd.Value;
          else
            oldValue = (P)fieldData.Value;
        }
        LoadPropertyValue<P>(propertyInfo, oldValue, Utilities.CoerceValue<P>(typeof(F), oldValue, newValue), false);
      }
      catch (Exception ex)
      {
        throw new PropertyLoadException(
          string.Format(Properties.Resources.PropertyLoadException, propertyInfo.Name, ex.Message), ex);
      }
    }
 
    void Core.IManageProperties.LoadProperty<P>(PropertyInfo<P> propertyInfo, P newValue)
    {
      LoadProperty<P>(propertyInfo, newValue);
    }
 
    bool Core.IManageProperties.FieldExists(Core.IPropertyInfo property)
    {
      return FieldManager.FieldExists(property);
    }
 
    protected void LoadProperty<P>(PropertyInfo<P> propertyInfo, P newValue)
    {
      try
      {
        P oldValue = default(P);
        var fieldData = FieldManager.GetFieldData(propertyInfo);
        if (fieldData == null)
        {
          oldValue = propertyInfo.DefaultValue;
          fieldData = FieldManager.LoadFieldData<P>(propertyInfo, oldValue);
        }
        else
        {
          var fd = fieldData as FieldManager.IFieldData<P>;
          if (fd != null)
            oldValue = fd.Value;
          else
            oldValue = (P)fieldData.Value;
        }
        LoadPropertyValue<P>(propertyInfo, oldValue, newValue, false);
      }
      catch (Exception ex)
      {
        throw new PropertyLoadException(
          string.Format(Properties.Resources.PropertyLoadException, propertyInfo.Name, ex.Message), ex);
      }
    }
 
    protected bool LoadPropertyMarkDirty<P>(PropertyInfo<P> propertyInfo, P newValue)
    {
      try
      {
        P oldValue = default(P);
        var fieldData = FieldManager.GetFieldData(propertyInfo);
        if (fieldData == null)
        {
          oldValue = propertyInfo.DefaultValue;
          fieldData = FieldManager.LoadFieldData<P>(propertyInfo, oldValue);
        }
        else
        {
          var fd = fieldData as FieldManager.IFieldData<P>;
          if (fd != null)
            oldValue = fd.Value;
          else
            oldValue = (P)fieldData.Value;
        }
 
        var valuesDiffer = ValuesDiffer(propertyInfo, newValue, oldValue);
        if (valuesDiffer)
        {
 
          IBusinessObject old = oldValue as IBusinessObject;
          if (old != null)
            RemoveEventHooks(old);
          IBusinessObject @new = newValue as IBusinessObject;
          if (@new != null)
            AddEventHooks(@new);
 
          if (typeof(IEditableBusinessObject).IsAssignableFrom(propertyInfo.Type))
          {
            FieldManager.SetFieldData<P>(propertyInfo, newValue);
            ResetChildEditLevel(newValue);
          }
          else if (typeof(IEditableCollection).IsAssignableFrom(propertyInfo.Type))
          {
            FieldManager.SetFieldData<P>(propertyInfo, newValue);
            ResetChildEditLevel(newValue);
          }
          else
          {
            FieldManager.SetFieldData<P>(propertyInfo, newValue);
          }
        }
        return valuesDiffer;
      }
      catch (Exception ex)
      {
        throw new PropertyLoadException(string.Format(Properties.Resources.PropertyLoadException, propertyInfo.Name, ex.Message), ex);
      }
    }
 
    private static bool ValuesDiffer<P>(PropertyInfo<P> propertyInfo, P newValue, P oldValue)
    {
      var valuesDiffer = false;
      if (oldValue == null)
        valuesDiffer = newValue != null;
      else
      {
        // use reference equals for objects that inherit from CSLA base class
        if (typeof (IBusinessObject).IsAssignableFrom(propertyInfo.Type))
        {
          valuesDiffer = !(ReferenceEquals(oldValue, newValue));
        }
        else
        {
          valuesDiffer = !(oldValue.Equals(newValue));
        }
      }
      return valuesDiffer;
    }
 
    private void LoadPropertyValue<P>(PropertyInfo<P> propertyInfo, P oldValue, P newValue, bool markDirty)
    {
      var valuesDiffer = ValuesDiffer(propertyInfo, newValue, oldValue);
 
      if (valuesDiffer)
      {
 
        IBusinessObject old = oldValue as IBusinessObject;
        if (old != null)
          RemoveEventHooks(old);
        IBusinessObject @new = newValue as IBusinessObject;
        if (@new != null)
          AddEventHooks(@new);
 
 
        if (typeof(IEditableBusinessObject).IsAssignableFrom(propertyInfo.Type))
        {
          if (markDirty)
          {
            OnPropertyChanging(propertyInfo);
            FieldManager.SetFieldData<P>(propertyInfo, newValue);
            PropertyHasChanged(propertyInfo);
          }
          else
          {
            FieldManager.LoadFieldData<P>(propertyInfo, newValue);
          }
          ResetChildEditLevel(newValue);
        }
        else if (typeof(IEditableCollection).IsAssignableFrom(propertyInfo.Type))
        {
          if (markDirty)
          {
            OnPropertyChanging(propertyInfo);
            FieldManager.SetFieldData<P>(propertyInfo, newValue);
            PropertyHasChanged(propertyInfo);
          }
          else
          {
            FieldManager.LoadFieldData<P>(propertyInfo, newValue);
          }
          ResetChildEditLevel(newValue);
        }
        else
        {
          if (markDirty)
          {
            OnPropertyChanging(propertyInfo);
            FieldManager.SetFieldData<P>(propertyInfo, newValue);
            PropertyHasChanged(propertyInfo);
          }
          else
          {
            FieldManager.LoadFieldData<P>(propertyInfo, newValue);
          }
        }
      }
    }
 
    protected virtual bool LoadPropertyMarkDirty(IPropertyInfo propertyInfo, object newValue)
    {
      // private field 
      if ((propertyInfo.RelationshipType & RelationshipTypes.PrivateField) == RelationshipTypes.PrivateField)
      {
        LoadProperty(propertyInfo, newValue);
        return false;
      }
 
#if IOS
      //manually call LoadProperty<T> if the type is nullable otherwise JIT error will occur
      if (propertyInfo.Type == typeof(int?))
      {
        return LoadPropertyMarkDirty((PropertyInfo<int?>)propertyInfo, (int?)newValue);
      }
      else if (propertyInfo.Type == typeof(bool?))
      {
        return LoadPropertyMarkDirty((PropertyInfo<bool?>)propertyInfo, (bool?)newValue);
      }
      else if (propertyInfo.Type == typeof(DateTime?))
      {
        return LoadPropertyMarkDirty((PropertyInfo<DateTime?>)propertyInfo, (DateTime?)newValue);
      }
      else if (propertyInfo.Type == typeof(decimal?))
      {
        return LoadPropertyMarkDirty((PropertyInfo<decimal?>)propertyInfo, (decimal?)newValue);
      }
      else if (propertyInfo.Type == typeof(double?))
      {
        return LoadPropertyMarkDirty((PropertyInfo<double?>)propertyInfo, (double?)newValue);
      }
      else if (propertyInfo.Type == typeof(long?))
      {
        return LoadPropertyMarkDirty((PropertyInfo<long?>)propertyInfo, (long?)newValue);
      }
      else if (propertyInfo.Type == typeof(byte?))
      {
        return LoadPropertyMarkDirty((PropertyInfo<byte?>)propertyInfo, (byte?)newValue);
      }
      else if (propertyInfo.Type == typeof(char?))
      {
        return LoadPropertyMarkDirty((PropertyInfo<char?>)propertyInfo, (char?)newValue);
      }
      else if (propertyInfo.Type == typeof(short?))
      {
        return LoadPropertyMarkDirty((PropertyInfo<short?>)propertyInfo, (short?)newValue);
      }
      else if (propertyInfo.Type == typeof(uint?))
      {
        return LoadPropertyMarkDirty((PropertyInfo<uint?>)propertyInfo, (uint?)newValue);
      }
      else if (propertyInfo.Type == typeof(ulong?))
      {
        return LoadPropertyMarkDirty((PropertyInfo<ulong?>)propertyInfo, (ulong?)newValue);
      }
      else if (propertyInfo.Type == typeof(ushort?))
      {
        return LoadPropertyMarkDirty((PropertyInfo<ushort?>)propertyInfo, (ushort?)newValue);
      }
      else
      {
        return (bool)LoadPropertyByReflection("LoadPropertyMarkDirty", propertyInfo, newValue);
      }
#else
      return (bool)LoadPropertyByReflection("LoadPropertyMarkDirty", propertyInfo, newValue);
#endif
    }
 
 
    protected virtual void LoadProperty(IPropertyInfo propertyInfo, object newValue)
    {
#if IOS
      //manually call LoadProperty<T> if the type is nullable otherwise JIT error will occur
      if (propertyInfo.Type == typeof(int?))
      {
        LoadProperty((PropertyInfo<int?>)propertyInfo, (int?)newValue);
      }
      else if (propertyInfo.Type == typeof(bool?))
      {
        LoadProperty((PropertyInfo<bool?>)propertyInfo, (bool?)newValue);
      }
      else if (propertyInfo.Type == typeof(DateTime?))
      {
        LoadProperty((PropertyInfo<DateTime?>)propertyInfo, (DateTime?)newValue);
      }
      else if (propertyInfo.Type == typeof(decimal?))
      {
        LoadProperty((PropertyInfo<decimal?>)propertyInfo, (decimal?)newValue);
      }
      else if (propertyInfo.Type == typeof(double?))
      {
        LoadProperty((PropertyInfo<double?>)propertyInfo, (double?)newValue);
      }
      else if (propertyInfo.Type == typeof(long?))
      {
        LoadProperty((PropertyInfo<long?>)propertyInfo, (long?)newValue);
      }
      else if (propertyInfo.Type == typeof(byte?))
      {
        LoadProperty((PropertyInfo<byte?>)propertyInfo, (byte?)newValue);
      }
      else if (propertyInfo.Type == typeof(char?))
      {
        LoadProperty((PropertyInfo<char?>)propertyInfo, (char?)newValue);
      }
      else if (propertyInfo.Type == typeof(short?))
      {
        LoadProperty((PropertyInfo<short?>)propertyInfo, (short?)newValue);
      }
      else if (propertyInfo.Type == typeof(uint?))
      {
        LoadProperty((PropertyInfo<uint?>)propertyInfo, (uint?)newValue);
      }
      else if (propertyInfo.Type == typeof(ulong?))
      {
        LoadProperty((PropertyInfo<ulong?>)propertyInfo, (ulong?)newValue);
      }
      else if (propertyInfo.Type == typeof(ushort?))
      {
        LoadProperty((PropertyInfo<ushort?>)propertyInfo, (ushort?)newValue);
      }
      else
      {
        LoadPropertyByReflection("LoadProperty", propertyInfo, newValue);
      }
#else
      LoadPropertyByReflection("LoadProperty", propertyInfo, newValue);
#endif
    }
 
    private object LoadPropertyByReflection(string loadPropertyMethodName, IPropertyInfo propertyInfo, object newValue)
    {
      var t = this.GetType();
      var flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
      var method = t.GetMethods(flags).FirstOrDefault(c => c.Name == loadPropertyMethodName && c.IsGenericMethod);
      var gm = method.MakeGenericMethod(propertyInfo.Type);
      var p = new object[] { propertyInfo, newValue };
      return gm.Invoke(this, p);
    }
 
    private void ResetChildEditLevel(object newValue)
    {
      IEditableBusinessObject child = newValue as IEditableBusinessObject;
      if (child != null)
      {
        child.SetParent(this);
        // set child edit level
        UndoableBase.ResetChildEditLevel(child, this.EditLevel, this.BindingEdit);
        // reset EditLevelAdded 
        child.EditLevelAdded = this.EditLevel;
      }
      else
      {
        IEditableCollection col = newValue as IEditableCollection;
        if (col != null)
        {
          col.SetParent(this);
          IUndoableObject undo = col as IUndoableObject;
          if (undo != null)
          {
            // set child edit level
            UndoableBase.ResetChildEditLevel(undo, this.EditLevel, this.BindingEdit);
          }
        }
      }
    }
 
    //private AsyncLoadManager
    [NonSerialized]
    [NotUndoable]
    private AsyncLoadManager _loadManager;
    internal AsyncLoadManager LoadManager
    {
      get
      {
        if (_loadManager == null)
        {
          _loadManager = new AsyncLoadManager(this, OnPropertyChanged);
          _loadManager.BusyChanged += loadManager_BusyChanged;
          _loadManager.UnhandledAsyncException += loadManager_UnhandledAsyncException;
        }
        return _loadManager;
      }
    }
 
    private void loadManager_UnhandledAsyncException(object sender, ErrorEventArgs e)
    {
      OnUnhandledAsyncException(e);
    }
 
    private void loadManager_BusyChanged(object sender, BusyChangedEventArgs e)
    {
      OnBusyChanged(e);
    }
 
    protected void LoadPropertyAsync<R>(PropertyInfo<R> property, Task<R> factory)
    {
      LoadManager.BeginLoad(new TaskLoader<R>(property, factory));
    }
 
#endregion
 
#region IsBusy / IsIdle
 
    [NonSerialized]
    [NotUndoable]
    private bool _isBusy;
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected void MarkBusy()
    {
      if (_isBusy)
        throw new InvalidOperationException(Resources.BusyObjectsMayNotBeMarkedBusy);
 
      _isBusy = true;
      OnBusyChanged(new BusyChangedEventArgs("", true));
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected void MarkIdle()
    {
      _isBusy = false;
      OnBusyChanged(new BusyChangedEventArgs("", false));
    }
 
    [Browsable(false)]
    [Display(AutoGenerateField = false)]
    [ScaffoldColumn(false)]
    public virtual bool IsBusy
    {
      get { return IsSelfBusy || (_fieldManager != null && FieldManager.IsBusy()); }
    }
 
    [Browsable(false)]
    [Display(AutoGenerateField = false)]
    [ScaffoldColumn(false)]
    public virtual bool IsSelfBusy
    {
      get { return _isBusy || BusinessRules.RunningAsyncRules || LoadManager.IsLoading; }
    }
 
    [NotUndoable]
    [NonSerialized]
    private BusyChangedEventHandler _busyChanged;
 
    public event BusyChangedEventHandler BusyChanged
    {
      add { _busyChanged = (BusyChangedEventHandler)Delegate.Combine(_busyChanged, value); }
      remove { _busyChanged = (BusyChangedEventHandler)Delegate.Remove(_busyChanged, value); }
    }
 
    protected virtual void OnBusyChanged(BusyChangedEventArgs args)
    {
      if (_busyChanged != null)
        _busyChanged(this, args);
      MetaPropertyHasChanged("IsSelfBusy");
      MetaPropertyHasChanged("IsBusy");
    }
 
    public virtual bool IsPropertyBusy(Csla.Core.IPropertyInfo property)
    {
      return BusinessRules.GetPropertyBusy(property);
    }
 
    public bool IsPropertyBusy(string propertyName)
    {
      return IsPropertyBusy(FieldManager.GetRegisteredProperty(propertyName));
    }
 
#endregion
 
#region INotifyUnhandledAsyncException Members
 
    [NotUndoable]
    [NonSerialized]
    private EventHandler<ErrorEventArgs> _unhandledAsyncException;
 
    public event EventHandler<ErrorEventArgs> UnhandledAsyncException
    {
      add { _unhandledAsyncException = (EventHandler<ErrorEventArgs>)Delegate.Combine(_unhandledAsyncException, value); }
      remove { _unhandledAsyncException = (EventHandler<ErrorEventArgs>)Delegate.Remove(_unhandledAsyncException, value); }
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void OnUnhandledAsyncException(ErrorEventArgs error)
    {
      if (_unhandledAsyncException != null)
        _unhandledAsyncException(this, error);
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected void OnUnhandledAsyncException(object originalSender, Exception error)
    {
      OnUnhandledAsyncException(new ErrorEventArgs(originalSender, error));
    }
 
#endregion
 
#region Child Change Notification
 
    [NonSerialized]
    [NotUndoable]
    private EventHandler<Csla.Core.ChildChangedEventArgs> _childChangedHandlers;
 
    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design",
      "CA1062:ValidateArgumentsOfPublicMethods")]
    public event EventHandler<Csla.Core.ChildChangedEventArgs> ChildChanged
    {
      add
      {
        _childChangedHandlers = (EventHandler<Csla.Core.ChildChangedEventArgs>)
          System.Delegate.Combine(_childChangedHandlers, value);
      }
      remove
      {
        _childChangedHandlers = (EventHandler<Csla.Core.ChildChangedEventArgs>)
          System.Delegate.Remove(_childChangedHandlers, value);
      }
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void OnChildChanged(ChildChangedEventArgs e)
    {
      if (_childChangedHandlers != null)
        _childChangedHandlers.Invoke(this, e);
      MetaPropertyHasChanged("IsDirty");
      MetaPropertyHasChanged("IsValid");
      MetaPropertyHasChanged("IsSavable");
    }
 
    private void RaiseChildChanged(ChildChangedEventArgs e)
    {
      OnChildChanged(e);
    }
 
    private void RaiseChildChanged(
      object childObject, PropertyChangedEventArgs propertyArgs)
    {
      ChildChangedEventArgs args = new ChildChangedEventArgs(childObject, propertyArgs);
      OnChildChanged(args);
    }
 
    private void RaiseChildChanged(
      object childObject, PropertyChangedEventArgs propertyArgs, ListChangedEventArgs listArgs)
    {
      ChildChangedEventArgs args = new ChildChangedEventArgs(childObject, propertyArgs, listArgs);
      OnChildChanged(args);
    }
 
    private void RaiseChildChanged(
      object childObject, PropertyChangedEventArgs propertyArgs, NotifyCollectionChangedEventArgs listArgs)
    {
      ChildChangedEventArgs args = new ChildChangedEventArgs(childObject, propertyArgs, listArgs);
      OnChildChanged(args);
    }
 
    private void Child_PropertyChanged(object sender, PropertyChangedEventArgs e)
    {
      // Issue 813
      // MetaPropertyHasChanged calls in OnChildChanged we're leading to exponential growth in OnChildChanged calls
      // Those notifications are for the UI. Ignore them here
      if (!(e is MetaPropertyChangedEventArgs))
      {
        RaiseChildChanged(sender, e);
      }
    }
 
    private void Child_ListChanged(object sender, ListChangedEventArgs e)
    {
      if (e.ListChangedType != ListChangedType.ItemChanged)
        RaiseChildChanged(sender, null, e);
    }
 
    private void Child_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
    {
      RaiseChildChanged(sender, null, e);
    }
 
    private void Child_Changed(object sender, ChildChangedEventArgs e)
    {
      RaiseChildChanged(e);
    }
 
#endregion
 
#region  Field Manager
 
    private FieldManager.FieldDataManager _fieldManager;
 
    protected FieldDataManager FieldManager
    {
      get
      {
        if (_fieldManager == null)
        {
          _fieldManager = new FieldDataManager(ApplicationContext, this.GetType());
          UndoableBase.ResetChildEditLevel(_fieldManager, this.EditLevel, this.BindingEdit);
        }
        return _fieldManager;
      }
    }
 
    FieldDataManager IUseFieldManager.FieldManager => FieldManager;
 
    private void FieldDataDeserialized()
    {
      foreach (object item in FieldManager.GetChildren())
      {
        if (item is IBusinessObject business)
          OnAddEventHooks(business);
 
        if (item is IEditableBusinessObject child)
        {
          child.SetParent(this);
        }
        if (item is IEditableCollection childCollection)
        {
          childCollection.SetParent(this);
        }
      }
    }
 
#endregion
 
#region  IParent
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void EditChildComplete(Core.IEditableBusinessObject child)
    {
      // do nothing, we don't really care
      // when a child has its edits applied
    }
 
    void IParent.ApplyEditChild(Core.IEditableBusinessObject child)
    {
      this.EditChildComplete(child);
    }
 
    void IParent.RemoveChild(IEditableBusinessObject child)
    {
      var info = FieldManager.FindProperty(child);
      FieldManager.RemoveField(info);
    }
 
    IParent Csla.Core.IParent.Parent
    {
      get { return this.Parent; }
    }
 
#endregion
 
#region IDataPortalTarget Members
 
    void Csla.Server.IDataPortalTarget.CheckRules()
    {
      BusinessRules.CheckRules();
    }
 
    void Csla.Server.IDataPortalTarget.MarkAsChild()
    {
      this.MarkAsChild();
    }
 
    void Csla.Server.IDataPortalTarget.MarkNew()
    {
      this.MarkNew();
    }
 
    void Csla.Server.IDataPortalTarget.MarkOld()
    {
      this.MarkOld();
    }
 
    void Csla.Server.IDataPortalTarget.DataPortal_OnDataPortalInvoke(DataPortalEventArgs e)
    {
      this.DataPortal_OnDataPortalInvoke(e);
    }
 
    void Csla.Server.IDataPortalTarget.DataPortal_OnDataPortalInvokeComplete(DataPortalEventArgs e)
    {
      this.DataPortal_OnDataPortalInvokeComplete(e);
    }
 
    void Csla.Server.IDataPortalTarget.DataPortal_OnDataPortalException(DataPortalEventArgs e, Exception ex)
    {
      this.DataPortal_OnDataPortalException(e, ex);
    }
 
    void Csla.Server.IDataPortalTarget.Child_OnDataPortalInvoke(DataPortalEventArgs e)
    {
      this.Child_OnDataPortalInvoke(e);
    }
 
    void Csla.Server.IDataPortalTarget.Child_OnDataPortalInvokeComplete(DataPortalEventArgs e)
    {
      this.Child_OnDataPortalInvokeComplete(e);
    }
 
    void Csla.Server.IDataPortalTarget.Child_OnDataPortalException(DataPortalEventArgs e, Exception ex)
    {
      this.Child_OnDataPortalException(e, ex);
    }
 
#endregion
 
#region IManageProperties Members
 
    bool IManageProperties.HasManagedProperties
    {
      get { return (_fieldManager != null && _fieldManager.HasFields); }
    }
 
    List<IPropertyInfo> IManageProperties.GetManagedProperties()
    {
      return FieldManager.GetRegisteredProperties();
    }
 
    object IManageProperties.GetProperty(IPropertyInfo propertyInfo)
    {
      return GetProperty(propertyInfo);
    }
 
    object IManageProperties.ReadProperty(IPropertyInfo propertyInfo)
    {
      return ReadProperty(propertyInfo);
    }
 
    P IManageProperties.ReadProperty<P>(PropertyInfo<P> propertyInfo)
    {
      return ReadProperty<P>(propertyInfo);
    }
 
    void IManageProperties.SetProperty(IPropertyInfo propertyInfo, object newValue)
    {
      SetProperty(propertyInfo, newValue);
    }
 
    void IManageProperties.LoadProperty(IPropertyInfo propertyInfo, object newValue)
    {
      LoadProperty(propertyInfo, newValue);
    }
 
    bool IManageProperties.LoadPropertyMarkDirty(IPropertyInfo propertyInfo, object newValue)
    {
      return LoadPropertyMarkDirty(propertyInfo, newValue);
    }
 
    List<object> IManageProperties.GetChildren()
    {
      return FieldManager.GetChildren();
    }
#endregion
 
#region MobileFormatter
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected override void OnGetState(Csla.Serialization.Mobile.SerializationInfo info, StateMode mode)
    {
      base.OnGetState(info, mode);
      info.AddValue("Csla.Core.BusinessBase._isNew", _isNew);
      info.AddValue("Csla.Core.BusinessBase._isDeleted", _isDeleted);
      info.AddValue("Csla.Core.BusinessBase._isDirty", _isDirty);
      info.AddValue("Csla.Core.BusinessBase._neverCommitted", _neverCommitted);
      info.AddValue("Csla.Core.BusinessBase._disableIEditableObject", _disableIEditableObject);
      info.AddValue("Csla.Core.BusinessBase._isChild", _isChild);
      info.AddValue("Csla.Core.BusinessBase._editLevelAdded", _editLevelAdded);
      info.AddValue("Csla.Core.BusinessBase._identity", _identity);
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected override void OnSetState(Csla.Serialization.Mobile.SerializationInfo info, StateMode mode)
    {
      base.OnSetState(info, mode);
      _isNew = info.GetValue<bool>("Csla.Core.BusinessBase._isNew");
      _isDeleted = info.GetValue<bool>("Csla.Core.BusinessBase._isDeleted");
      _isDirty = info.GetValue<bool>("Csla.Core.BusinessBase._isDirty");
      _neverCommitted = info.GetValue<bool>("Csla.Core.BusinessBase._neverCommitted");
      _disableIEditableObject = info.GetValue<bool>("Csla.Core.BusinessBase._disableIEditableObject");
      _isChild = info.GetValue<bool>("Csla.Core.BusinessBase._isChild");
      if (mode != StateMode.Undo)
        _editLevelAdded = info.GetValue<int>("Csla.Core.BusinessBase._editLevelAdded");
      _identity = info.GetValue<int>("Csla.Core.BusinessBase._identity");
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected override void OnGetChildren(
      Csla.Serialization.Mobile.SerializationInfo info, Csla.Serialization.Mobile.MobileFormatter formatter)
    {
      base.OnGetChildren(info, formatter);
 
      if (_fieldManager != null)
      {
        var fieldManagerInfo = formatter.SerializeObject(_fieldManager);
        info.AddChild("_fieldManager", fieldManagerInfo.ReferenceId);
      }
 
      if (_businessRules != null)
      {
        var vrInfo = formatter.SerializeObject(_businessRules);
        info.AddChild("_businessRules", vrInfo.ReferenceId);
      }
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected override void OnSetChildren(Csla.Serialization.Mobile.SerializationInfo info, Csla.Serialization.Mobile.MobileFormatter formatter)
    {
      if (info.Children.ContainsKey("_fieldManager"))
      {
        var childData = info.Children["_fieldManager"];
        _fieldManager = (FieldManager.FieldDataManager)formatter.GetObject(childData.ReferenceId);
      }
 
      if (info.Children.ContainsKey("_businessRules"))
      {
        int refId = info.Children["_businessRules"].ReferenceId;
        _businessRules = (BusinessRules)formatter.GetObject(refId);
      }
 
      base.OnSetChildren(info, formatter);
    }
 
#endregion
 
#region Property Checks ByPass
 
    [NonSerialized]
    [NotUndoable]
    private bool _bypassPropertyChecks = false;
 
    protected internal bool IsBypassingPropertyChecks { get { return _bypassPropertyChecks; } }
  
    [NonSerialized]
    [NotUndoable]
    private BypassPropertyChecksObject _bypassPropertyChecksObject = null;
 
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    protected internal BypassPropertyChecksObject BypassPropertyChecks
    {
      get
      {
        return BypassPropertyChecksObject.GetManager(this);
      }
    }
 
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected internal class BypassPropertyChecksObject : IDisposable
    {
      private BusinessBase _businessObject;
      private static object _lock = new object();
 
      internal BypassPropertyChecksObject(BusinessBase businessObject)
      {
        _businessObject = businessObject;
        _businessObject._bypassPropertyChecks = true;
      }
 
#region IDisposable Members
 
      public void Dispose()
      {
        Dispose(true);
        GC.SuppressFinalize(this);
      }
 
      protected virtual void Dispose(bool dispose)
      {
        DeRef();
      }
 
      public static BypassPropertyChecksObject GetManager(BusinessBase businessObject)
      {
        lock (_lock)
        {
          if (businessObject._bypassPropertyChecksObject == null)
            businessObject._bypassPropertyChecksObject = new BypassPropertyChecksObject(businessObject);
 
          businessObject._bypassPropertyChecksObject.AddRef();
        }
        return businessObject._bypassPropertyChecksObject;
      }
 
#region  Reference counting
 
      private int _refCount;
 
      public int RefCount
      {
        get { return _refCount; }
      }
 
      private void AddRef()
      {
        _refCount += 1;
      }
 
      private void DeRef()
      {
 
        lock (_lock)
        {
          _refCount -= 1;
          if (_refCount == 0)
          {
            _businessObject._bypassPropertyChecks = false;
            _businessObject._bypassPropertyChecksObject = null;
            _businessObject = null;
          }
        }
      }
 
#endregion
#endregion
    }
 
#endregion
 
#region ISuppressRuleChecking Members
 
    void ICheckRules.SuppressRuleChecking()
    {
      BusinessRules.SuppressRuleChecking = true;
    }
 
    void ICheckRules.ResumeRuleChecking()
    {
      BusinessRules.SuppressRuleChecking = false;
    }
 
    void ICheckRules.CheckRules()
    {
      BusinessRules.CheckRules();
    }
 
    Task ICheckRules.CheckRulesAsync()
    {
      return BusinessRules.CheckRulesAsync();
    }
 
    public BrokenRulesCollection GetBrokenRules()
    {
      return BrokenRulesCollection;
    }
 
    #endregion
  }
}