BusinessListBase.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="BusinessListBase.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>This is the base class from which most business collections</summary>
//-----------------------------------------------------------------------
using System;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using Csla.Core;
using Csla.Properties;
using System.Collections.Generic;
using System.Collections.Specialized;
using Csla.DataPortalClient;
using Csla.Serialization.Mobile;
using Csla.Server;
using System.Linq;
using System.Threading.Tasks;
 
namespace Csla
{
#if TESTING
  [System.Diagnostics.DebuggerStepThrough]
#endif
  [Serializable]
  public abstract class BusinessListBase<T, C> :
      ObservableBindingList<C>, IContainsDeletedList,
      IEditableCollection, Core.IUndoableObject, ICloneable,
      ISavable, Core.ISavable<T>, Core.IParent,  Server.IDataPortalTarget,
      INotifyBusy,
      IBusinessListBase<C>,
      IUseApplicationContext
    where T : BusinessListBase<T, C>
    where C : Core.IEditableBusinessObject
  {
    protected BusinessListBase()
    { }
 
    protected ApplicationContext ApplicationContext { get; private set; }
    ApplicationContext Core.IUseApplicationContext.ApplicationContext
    {
      get => ApplicationContext;
      set
      {
        ApplicationContext = value;
        InitializeIdentity();
        Initialize();
        AllowNew = true;
      }
    }
 
    #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 ICloneable
 
    object ICloneable.Clone()
    {
      return GetClone();
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual object GetClone()
    {
      return Core.ObjectCloner.GetInstance(ApplicationContext).Clone(this);
    }
 
    public T Clone()
    {
      return (T)GetClone();
    }
 
    #endregion
 
    #region Delete and Undelete child
 
    private MobileList<C> _deletedList;
 
    [System.Diagnostics.CodeAnalysis.SuppressMessage(
      "Microsoft.Design", "CA1002:DoNotExposeGenericLists")]
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected MobileList<C> DeletedList
    {
      get
      {
        if (_deletedList == null)
          _deletedList = new MobileList<C>();
        return _deletedList;
      }
    }
 
    [System.Diagnostics.CodeAnalysis.SuppressMessage(
      "Microsoft.Design", "CA1002:DoNotExposeGenericLists")]
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    IEnumerable<IEditableBusinessObject> IContainsDeletedList.DeletedList => (IEnumerable<IEditableBusinessObject>)DeletedList;
 
    private void DeleteChild(C child)
    {
      // set child edit level
      Core.UndoableBase.ResetChildEditLevel(child, this.EditLevel, false);
 
      // mark the object as deleted
      child.DeleteChild();
      // and add it to the deleted collection for storage
      DeletedList.Add(child);
    }
 
    private void UnDeleteChild(C child)
    {
      // since the object is no longer deleted, remove it from
      // the deleted collection
      DeletedList.Remove(child);
 
      // we are inserting an _existing_ object so
      // we need to preserve the object's editleveladded value
      // because it will be changed by the normal add process
      int saveLevel = child.EditLevelAdded;
 
      Add(child);
      child.EditLevelAdded = saveLevel;
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public bool ContainsDeleted(C item)
    {
      return DeletedList.Contains(item);
    }
 
    #endregion
 
    #region Begin/Cancel/ApplyEdit
 
    public void BeginEdit()
    {
      if (this.IsChild)
        throw new NotSupportedException(Resources.NoBeginEditChildException);
 
      CopyState(this.EditLevel + 1);
    }
 
    public void CancelEdit()
    {
      if (this.IsChild)
        throw new NotSupportedException(Resources.NoCancelEditChildException);
 
      UndoChanges(this.EditLevel - 1);
    }
 
    public void ApplyEdit()
    {
      if (this.IsChild)
        throw new NotSupportedException(Resources.NoApplyEditChildException);
 
      AcceptChanges(this.EditLevel - 1);
    }
 
    void Core.IParent.ApplyEditChild(Core.IEditableBusinessObject child)
    {
      EditChildComplete(child);
    }
 
    IParent Core.IParent.Parent
    {
      get { return this.Parent; }
    }
 
    protected virtual void EditChildComplete(Core.IEditableBusinessObject child)
    {
 
      // do nothing, we don't really care
      // when a child has its edits applied
    }
 
    #endregion
 
    #region Insert, Remove, Clear
 
    protected override C AddNewCore()
    {
      var dp = ApplicationContext.CreateInstanceDI<DataPortal<C>>();
      var item = dp.CreateChild();
      Add(item);
      return item;
    }
 
    void IEditableCollection.RemoveChild(IEditableBusinessObject child)
    {
      Remove((C)child);
    }
 
    object IEditableCollection.GetDeletedList()
    {
      return DeletedList;
    }
 
    void Core.IParent.RemoveChild(Csla.Core.IEditableBusinessObject child)
    {
      Remove((C)child);
    }
 
    protected override void InsertItem(int index, C item)
    {
      if (item.IsChild)
      {
        // set parent reference
        item.SetParent(this);
        // set child edit level
        Core.UndoableBase.ResetChildEditLevel(item, this.EditLevel, false);
        // when an object is inserted we assume it is
        // a new object and so the edit level when it was
        // added must be set
        item.EditLevelAdded = _editLevel;
        base.InsertItem(index, item);
      }
      else
      {
        // item must be marked as a child object
        throw new InvalidOperationException(Resources.ListItemNotAChildException);
      }
    }
 
    protected override void RemoveItem(int index)
    {
      // when an object is 'removed' it is really
      // being deleted, so do the deletion work
      C child = this[index];
      using (LoadListMode)
      {
        base.RemoveItem(index);
      }
      if (!_completelyRemoveChild)
      {
        // the child shouldn't be completely removed,
        // so copy it to the deleted list
        DeleteChild(child);
      }
      if (RaiseListChangedEvents)
        OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, child, index));
    }
 
    protected override void SetItem(int index, C item)
    {
      C child = default(C);
      if (!(ReferenceEquals((C)(this[index]), item)))
        child = this[index];
      // replace the original object with this new
      // object
      using (LoadListMode)
      {
        if (child != null)
          DeleteChild(child);
      }
 
      // set parent reference
      item.SetParent(this);
      // set child edit level
      Core.UndoableBase.ResetChildEditLevel(item, this.EditLevel, false);
      // reset EditLevelAdded 
      item.EditLevelAdded = this.EditLevel;
      // add to list and raise list changed as appropriate
      base.SetItem(index, item);
    }
 
    protected override void ClearItems()
    {
      while (base.Count > 0) RemoveItem(0);
      //DeferredLoadIndexIfNotLoaded();
      //_indexSet.ClearIndexes();
      //DeferredLoadPositionMapIfNotLoaded();
      //_positionMap.ClearMap();
      base.ClearItems();
    }
 
    #endregion
 
    #region Edit level tracking
 
    // keep track of how many edit levels we have
    private int _editLevel;
 
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected int EditLevel
    {
      get { return _editLevel; }
    }
 
    int Core.IUndoableObject.EditLevel
    {
      get
      {
        return this.EditLevel;
      }
    }
 
    #endregion
 
    #region N-level undo
 
    void Core.IUndoableObject.CopyState(int parentEditLevel, bool parentBindingEdit)
    {
      if (!parentBindingEdit)
        CopyState(parentEditLevel);
    }
 
    void Core.IUndoableObject.UndoChanges(int parentEditLevel, bool parentBindingEdit)
    {
      if (!parentBindingEdit)
        UndoChanges(parentEditLevel);
    }
 
    void Core.IUndoableObject.AcceptChanges(int parentEditLevel, bool parentBindingEdit)
    {
      if (!parentBindingEdit)
        AcceptChanges(parentEditLevel);
    }
 
    private void CopyState(int parentEditLevel)
    {
      if (this.EditLevel + 1 > parentEditLevel)
        throw new UndoException(string.Format(Resources.EditLevelMismatchException, "CopyState"), this.GetType().Name, _parent != null ? _parent.GetType().Name : null, this.EditLevel, parentEditLevel - 1);
 
      // we are going a level deeper in editing
      _editLevel += 1;
 
      // cascade the call to all child objects
      for (int x = 0; x < this.Count; x++)
      {
        C child = this[x];
        child.CopyState(_editLevel, false);
      }
 
      // cascade the call to all deleted child objects
      foreach (C child in DeletedList)
        child.CopyState(_editLevel, false);
    }
 
    private bool _completelyRemoveChild;
 
    private void UndoChanges(int parentEditLevel)
    {
      C child;
 
      if (this.EditLevel - 1 != parentEditLevel)
        throw new UndoException(string.Format(Resources.EditLevelMismatchException, "UndoChanges"), this.GetType().Name, _parent != null ? _parent.GetType().Name : null, this.EditLevel, parentEditLevel + 1);
 
      // we are coming up one edit level
      _editLevel -= 1;
      if (_editLevel < 0) _editLevel = 0;
 
      using (LoadListMode)
      {
        try
        {
          // Cancel edit on all current items
          for (int index = Count - 1; index >= 0; index--)
          {
            child = this[index];
 
            //ACE: Important, make sure to remove the item prior to
            //     it going through undo, otherwise, it will
            //     incur a more expensive RemoveByReference operation
            //DeferredLoadIndexIfNotLoaded();
            //_indexSet.RemoveItem(child);
 
            child.UndoChanges(_editLevel, false);
 
            //ACE: Now that we have undone the changes, we can add the item
            //     back in the index.
            //_indexSet.InsertItem(child);
 
            // if item is below its point of addition, remove
            if (child.EditLevelAdded > _editLevel)
            {
              bool oldAllowRemove = this.AllowRemove;
              try
              {
                this.AllowRemove = true;
                _completelyRemoveChild = true;
                //RemoveIndexItem(child);
                RemoveAt(index);
              }
              finally
              {
                _completelyRemoveChild = false;
                this.AllowRemove = oldAllowRemove;
              }
            }
          }
 
          // cancel edit on all deleted items
          for (int index = DeletedList.Count - 1; index >= 0; index--)
          {
            child = DeletedList[index];
            child.UndoChanges(_editLevel, false);
            if (child.EditLevelAdded > _editLevel)
            {
              // if item is below its point of addition, remove
              DeletedList.RemoveAt(index);
            }
            else
            {
              // if item is no longer deleted move back to main list
              if (!child.IsDeleted) UnDeleteChild(child);
            }
          }
        }
        finally
        {
          OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
        }
      }
    }
 
    private void AcceptChanges(int parentEditLevel)
    {
      if (this.EditLevel - 1 != parentEditLevel)
        throw new UndoException(string.Format(Resources.EditLevelMismatchException, "AcceptChanges"), this.GetType().Name, _parent != null ? _parent.GetType().Name : null, this.EditLevel, parentEditLevel + 1);
 
      // we are coming up one edit level
      _editLevel -= 1;
 
      // cascade the call to all child objects
      foreach (C child in this)
      {
        child.AcceptChanges(_editLevel, false);
        // if item is below its point of addition, lower point of addition
        if (child.EditLevelAdded > _editLevel) child.EditLevelAdded = _editLevel;
      }
 
      // cascade the call to all deleted child objects
      for (int index = DeletedList.Count - 1; index >= 0; index--)
      {
        C child = DeletedList[index];
        child.AcceptChanges(_editLevel, false);
        // if item is below its point of addition, remove
        if (child.EditLevelAdded > _editLevel)
          DeletedList.RemoveAt(index);
      }
      
      if (_editLevel < 0) _editLevel = 0;
    }
 
    #endregion
 
    #region Mobile Object overrides
 
    protected override void OnGetState(SerializationInfo info)
    {
      info.AddValue("Csla.BusinessListBase._isChild", _isChild);
      info.AddValue("Csla.BusinessListBase._editLevel", _editLevel);
      info.AddValue("Csla.Core.BusinessBase._identity", _identity);
      base.OnGetState(info);
    }
 
    protected override void OnSetState(SerializationInfo info)
    {
      _isChild = info.GetValue<bool>("Csla.BusinessListBase._isChild");
      _editLevel = info.GetValue<int>("Csla.BusinessListBase._editLevel");
      _identity = info.GetValue<int>("Csla.Core.BusinessBase._identity");
      base.OnSetState(info);
    }
 
    protected override void OnGetChildren(Csla.Serialization.Mobile.SerializationInfo info, Csla.Serialization.Mobile.MobileFormatter formatter)
    {
      base.OnGetChildren(info, formatter);
      if (_deletedList != null)
      {
        var fieldManagerInfo = formatter.SerializeObject(_deletedList);
        info.AddChild("_deletedList", fieldManagerInfo.ReferenceId);
      }
    }
 
    protected override void OnSetChildren(Csla.Serialization.Mobile.SerializationInfo info, Csla.Serialization.Mobile.MobileFormatter formatter)
    {
      if (info.Children.ContainsKey("_deletedList"))
      {
        var childData = info.Children["_deletedList"];
        _deletedList = (MobileList<C>)formatter.GetObject(childData.ReferenceId);
      }
      base.OnSetChildren(info, formatter);
    }
 
    #endregion
 
    #region IsChild
 
    [NotUndoable()]
    private bool _isChild = false;
 
    public bool IsChild
    {
      get { return _isChild; }
    }
 
    protected void MarkAsChild()
    {
      _identity = -1;
      _isChild = true;
    }
 
    #endregion
 
    #region IsDirty, IsValid, IsSavable
 
    bool Core.ITrackStatus.IsSelfDirty
    {
      get { return IsDirty; }
    }
 
    public bool IsDirty
    {
      get
      {
        // any non-new deletions make us dirty
        foreach (C item in DeletedList)
          if (!item.IsNew)
            return true;
 
        // run through all the child objects
        // and if any are dirty then then
        // collection is dirty
        foreach (C child in this)
          if (child.IsDirty)
            return true;
        return false;
      }
    }
 
    bool Core.ITrackStatus.IsSelfValid
    {
      get { return IsSelfValid; }
    }
 
    protected virtual bool IsSelfValid
    {
      get { return IsValid; }
    }
 
    public virtual bool IsValid
    {
      get
      {
        // run through all the child objects
        // and if any are invalid then the
        // collection is invalid
        foreach (C child in this)
          if (!child.IsValid)
            return false;
        return true;
      }
    }
 
    public virtual bool IsSavable
    {
      get
      {
        bool auth = Csla.Rules.BusinessRules.HasPermission(ApplicationContext, Rules.AuthorizationActions.EditObject, this);
        return (IsDirty && IsValid && auth && !IsBusy);
      }
    }
 
    public override bool IsBusy
    {
      get
      {
        // run through all the child objects
        // and if any are busy then then
        // collection is busy
        foreach (C item in DeletedList)
          if (item.IsBusy)
            return true;
 
        foreach (C child in this)
          if (child.IsBusy)
            return true;
 
        return false;
      }
    }
 
    #endregion
 
    #region  ITrackStatus
 
    bool Core.ITrackStatus.IsNew
    {
      get
      {
        return false;
      }
    }
 
    bool Core.ITrackStatus.IsDeleted
    {
      get
      {
        return false;
      }
    }
 
    #endregion
 
    #region Serialization Notification
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected override void OnDeserialized()
    {
      base.OnDeserialized();
      foreach (Core.IEditableBusinessObject child in this)
        child.SetParent(this);
 
      foreach (Core.IEditableBusinessObject child in DeletedList)
        child.SetParent(this);
    }
 
    #endregion
 
    #region  Child Data Access
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void Child_Create()
    { /* do nothing - list self-initializes */ }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void Child_Update(params object[] parameters)
    {
      using (LoadListMode)
      {
        var dp = ApplicationContext.CreateInstanceDI<DataPortal<C>>();
        foreach (var child in DeletedList)
          dp.UpdateChild(child, parameters);
        DeletedList.Clear();
 
        foreach (var child in this)
          if (child.IsDirty) dp.UpdateChild(child, parameters);
      }
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    [UpdateChild]
    protected virtual async Task Child_UpdateAsync(params object[] parameters)
    {
      using (LoadListMode)
      {
        var dp = ApplicationContext.CreateInstanceDI<DataPortal<C>>();
        foreach (var child in DeletedList)
          await dp.UpdateChildAsync(child, parameters).ConfigureAwait(false);
        DeletedList.Clear();
 
        foreach (var child in this)
          if (child.IsDirty) await dp.UpdateChildAsync(child, parameters).ConfigureAwait(false);
      }
    }
 
    #endregion
 
    #region Data Access
 
    public T Save()
    {
      try
      {
        return SaveAsync(null, true).Result;
      }
      catch (AggregateException ex)
      {
        if (ex.InnerExceptions.Count > 0)
          throw ex.InnerExceptions[0];
        else
          throw;
      }
    }
 
    public async Task<T> SaveAsync()
    {
      return await SaveAsync(null, false);
    }
 
    protected virtual async Task<T> SaveAsync(object userState, bool isSync)
    {
      T result;
      if (this.IsChild)
        throw new InvalidOperationException(Resources.NoSaveChildException);
 
      if (_editLevel > 0)
        throw new InvalidOperationException(Resources.NoSaveEditingException);
 
      if (!IsValid)
        throw new Rules.ValidationException(Resources.NoSaveInvalidException);
 
      if (IsBusy)
        throw new InvalidOperationException(Resources.BusyObjectsMayNotBeSaved);
 
      if (IsDirty)
      {
        var dp = ApplicationContext.CreateInstanceDI<DataPortal<T>>();
        if (isSync)
        {
          result = dp.Update((T)this);
        }
        else
        {
          result = await dp.UpdateAsync((T)this);
        }
      }
      else
      {
        result = (T)this;
      }
      OnSaved(result, null, userState);
      return result;
    }
 
    public async Task SaveAndMergeAsync()
    {
      new GraphMerger(ApplicationContext).MergeBusinessListGraph<T, C>((T)this, await SaveAsync());
    }
 
    [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)
    { }
 
    [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 ISavable Members
 
    object Csla.Core.ISavable.Save()
    {
      return Save();
    }
 
    object Csla.Core.ISavable.Save(bool forceUpdate)
    {
      return Save();
    }
 
    async Task<object> ISavable.SaveAsync()
    {
      return await SaveAsync();
    }
 
    async Task<object> ISavable.SaveAsync(bool forceUpdate)
    {
      return await SaveAsync();
    }
 
    async Task ISavable.SaveAndMergeAsync(bool forceUpdate)
    {
      await SaveAndMergeAsync();
    }
 
    void Csla.Core.ISavable.SaveComplete(object newObject)
    {
      OnSaved((T)newObject, null, null);
    }
 
    T Csla.Core.ISavable<T>.Save(bool forceUpdate)
    {
      return Save();
    }
 
    async Task<T> ISavable<T>.SaveAsync(bool forceUpdate)
    {
      return await SaveAsync();
    }
 
    async Task ISavable<T>.SaveAndMergeAsync(bool forceUpdate)
    {
      await SaveAndMergeAsync();
    }
 
    void Csla.Core.ISavable<T>.SaveComplete(T newObject)
    {
      OnSaved(newObject, null, null);
    }
 
    [NonSerialized()]
    [NotUndoable]
    private EventHandler<Csla.Core.SavedEventArgs> _savedEvent;
 
    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design",
      "CA1062:ValidateArgumentsOfPublicMethods")]
    public event EventHandler<Csla.Core.SavedEventArgs> Saved
    {
      add
      {
        _savedEvent = (EventHandler<Csla.Core.SavedEventArgs>)
          System.Delegate.Combine(_savedEvent, value);
      }
      remove
      {
        _savedEvent = (EventHandler<Csla.Core.SavedEventArgs>)
          System.Delegate.Remove(_savedEvent, value);
      }
    }
 
    [System.ComponentModel.EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void OnSaved(T newObject, Exception e, object userState)
    {
      Csla.Core.SavedEventArgs args = new Csla.Core.SavedEventArgs(newObject, e, userState);
      if (_savedEvent != null)
        _savedEvent.Invoke(this, args);
    }
    #endregion
 
    #region  Parent/Child link
 
    [NotUndoable(), NonSerialized()]
    private Core.IParent _parent;
 
    [Browsable(false)]
    [Display(AutoGenerateField=false)]
    [System.ComponentModel.DataAnnotations.ScaffoldColumn(false)]
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public Core.IParent Parent
    {
      get
      {
        return _parent;
      }
    }
 
    protected virtual void SetParent(Core.IParent parent)
    {
      _parent = parent;
      _identityManager = null;
      InitializeIdentity();
    }
 
    void Core.IEditableCollection.SetParent(Core.IParent parent)
    {
      this.SetParent(parent);
    }
 
    #endregion
 
    #region IDataPortalTarget Members
 
    void IDataPortalTarget.CheckRules()
    { }
 
    void IDataPortalTarget.MarkAsChild()
    {
      this.MarkAsChild();
    }
 
    void IDataPortalTarget.MarkNew()
    { }
 
    void IDataPortalTarget.MarkOld()
    { }
 
    void IDataPortalTarget.DataPortal_OnDataPortalInvoke(DataPortalEventArgs e)
    {
      this.DataPortal_OnDataPortalInvoke(e);
    }
 
    void IDataPortalTarget.DataPortal_OnDataPortalInvokeComplete(DataPortalEventArgs e)
    {
      this.DataPortal_OnDataPortalInvokeComplete(e);
    }
 
    void IDataPortalTarget.DataPortal_OnDataPortalException(DataPortalEventArgs e, Exception ex)
    {
      this.DataPortal_OnDataPortalException(e, ex);
    }
 
    void IDataPortalTarget.Child_OnDataPortalInvoke(DataPortalEventArgs e)
    {
      this.Child_OnDataPortalInvoke(e);
    }
 
    void IDataPortalTarget.Child_OnDataPortalInvokeComplete(DataPortalEventArgs e)
    {
      this.Child_OnDataPortalInvokeComplete(e);
    }
 
    void IDataPortalTarget.Child_OnDataPortalException(DataPortalEventArgs e, Exception ex)
    {
      this.Child_OnDataPortalException(e, ex);
    }
 
    #endregion
 
  }
}