DynamicListBase.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="DynamicListBase.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>This is the base class from which collections</summary>
//-----------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Threading.Tasks;
using Csla.Core;
using Csla.Reflection;
using Csla.Serialization.Mobile;
 
namespace Csla
{
  [Serializable()]
  public abstract class DynamicListBase<T> :
#if (ANDROID || IOS) || NETFX_CORE
    ExtendedBindingList<T>,
#else
    ObservableBindingList<T>,
#endif
    Core.IParent, Csla.Server.IDataPortalTarget, ISerializationNotification, IBusinessObject, IUseApplicationContext
    where T : Core.IEditableBusinessObject, Core.IUndoableObject, Core.ISavable, IMobileObject, IBusinessObject
  {
    public DynamicListBase()
    {
      InitializeIdentity();
      Initialize();
      AllowNew = true;
    }
 
    protected ApplicationContext ApplicationContext { get; private set; }
    ApplicationContext IUseApplicationContext.ApplicationContext { get => ApplicationContext; set => ApplicationContext = value; }
 
    #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)
    {
      var me = (IParent)this;
      if (me.Parent != null)
      {
        return me.Parent.GetNextIdentity(current);
      }
      else
      {
        if (_identityManager == null)
          _identityManager = new IdentityManager();
        return _identityManager.GetNextIdentity(current);
      }
    }
 
    #endregion
 
    #region  SaveItem Methods
 
    public event EventHandler<Csla.Core.SavedEventArgs> Saved;
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void OnSaved(T newObject, Exception error)
    {
      if (Saved != null)
        Saved(this, new SavedEventArgs(newObject, error, null));
    }
 
    public async Task SaveItemAsync(T item)
    {
      await SaveItemAsync(IndexOf(item));
    }
 
    public async Task SaveItemAsync(int index)
    {
      await SaveItemAsync(index, false);
    }
 
    protected virtual async Task SaveItemAsync(int index, bool delete)
    {
      T item = this[index];
      var handleBusy = false;
      if ((item.IsDeleted || delete) || (item.IsValid && item.IsDirty))
      {
        T savable = item;
 
        // attempt to clone object
        ICloneable cloneable = savable as ICloneable;
        if (cloneable != null)
        {
          savable = (T)cloneable.Clone();
          MethodCaller.CallMethodIfImplemented(item, "MarkBusy");
          handleBusy = true;
        }
 
        // commit all changes
        int editLevel = savable.EditLevel;
        for (int tmp = 1; tmp <= editLevel; tmp++)
          savable.AcceptChanges(editLevel - tmp, false);
 
        if (delete)
          savable.Delete();
 
        Exception error = null;
        T result = default(T);
        var dp = ApplicationContext.CreateInstanceDI<DataPortal<T>>();
        try
        {
          result = await dp.UpdateAsync((T)savable);
        }
        catch (AggregateException ex)
        {
          if (ex.InnerExceptions.Count > 0)
            error = ex.InnerExceptions[0];
          else
            error = ex;
        }
        catch (Exception ex)
        {
          error = ex;
        }
        finally
        {
          if (handleBusy)
            MethodCaller.CallMethodIfImplemented(item, "MarkIdle");
        }
        // update index - this may have changed under the duration of async call 
        index = IndexOf(item);
        if (error == null && result != null)
        {
          if (savable.IsDeleted)
          {
            //SafeRemoveItem  will raise INotifyCollectionChanged event
            SafeRemoveItem(index);
          }
          else
          {
            for (int tmp = 1; tmp <= editLevel; tmp++)
              result.CopyState(tmp, false);
 
            SafeSetItem(index, result);
            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, item, index));
            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, this[index], index));
          }
          item.SaveComplete(result);
          OnSaved(result, null);
        }
        else
        {
          item.SaveComplete(item);
          OnSaved(item, error);
        }
      }
    }
 
    public void SaveItem(T item)
    {
      SaveItem(IndexOf(item));
    }
 
    public async void SaveItem(int index)
    {
      try
      {
        await SaveItemAsync(index);
      }
      catch (AggregateException ex)
      {
        if (ex.InnerExceptions.Count > 0)
          throw ex.InnerExceptions[0];
        else
          throw;
      }
    }
 
    private void SafeSetItem(int index, T newObject)
    {
      //This is needed because we cannot call base.SetItem from lambda expression
      this[index].SetParent(null);
      base.OnRemoveEventHooks(this[index]);
      newObject.SetParent(this);
      base.SetItem(index, newObject);
      base.OnAddEventHooks(newObject);
    }
 
    private void SafeRemoveItem(int index)
    {
      this[index].SetParent(null);
      base.OnRemoveEventHooks(this[index]);
      base.RemoveItem(index);
    }
 
    #endregion
 
    #region  Insert, Remove, Clear
 
    protected override T AddNewCore()
    {
      var dp = ApplicationContext.CreateInstanceDI<DataPortal<T>>();
      T item = dp.Create();
      Add(item);
      return item;
    }
 
    protected override void InsertItem(int index, T item)
    {
      item.SetParent(this);
      base.InsertItem(index, item);
    }
 
    protected override async void RemoveItem(int index)
    {
      T item = this[index];
      if (item.IsDeleted == false)
      {
        // only delete/save the item if it is not new
        if (!item.IsNew)
        {
          try
          {
            await SaveItemAsync(index, true);
          }
          catch (AggregateException ex)
          {
            if (ex.InnerExceptions.Count > 0)
              throw ex.InnerExceptions[0];
            else
              throw;
          }
        }
        else
        {
          SafeRemoveItem(index);
          OnSaved(item, null);
        }
      }
    }
 
    protected override void SetItem(int index, T item)
    {
      item.SetParent(this);
      base.SetItem(index, item);
    }
 
    #endregion
 
    #region  IParent Members
 
    protected bool RaiseReplaceEvents { get; set; }
 
    protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
    {
      // SL Data Grid's DataGridDataConnection object does not support replace action.  
      // It throws an excpetioon when this occurs.
      if (this.RaiseListChangedEvents && (e.Action != NotifyCollectionChangedAction.Replace || RaiseReplaceEvents))
        base.OnCollectionChanged(e);
    }
 
    protected override bool SupportsChangeNotificationCore
    {
      get
      {
        return true;
      }
    }
 
    void Csla.Core.IParent.ApplyEditChild(Core.IEditableBusinessObject child)
    {
      if (child.EditLevel == 0)
        SaveItem((T)child);
    }
 
    void Csla.Core.IParent.RemoveChild(Core.IEditableBusinessObject child)
    {
      // do nothing, removal of a child is handled by
      // the RemoveItem override
    }
 
 
    IParent  Csla.Core.IParent.Parent
    {
      get { return null;  }
    }
 
    #endregion
 
    #region IsBusy
 
    public override bool IsBusy
    {
      get
      {
        // run through all the child objects
        // and if any are dirty then then
        // collection is dirty
        foreach (T child in this)
          if (child.IsBusy)
            return true;
 
        return false;
      }
    }
    #endregion
 
    #region  Serialization Notification
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected override void OnDeserialized()
    {
      foreach (IEditableBusinessObject child in this)
        child.SetParent(this);
 
      base.OnDeserialized();
    }
 
    #endregion
 
    #region  Data Access
 
    private void DataPortal_Update()
    {
      throw new NotSupportedException(Properties.Resources.UpdateNotSupportedException);
    }
 
    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "criteria")]
    [Delete]
    private void DataPortal_Delete(object criteria)
    {
      throw new NotSupportedException(Properties.Resources.DeleteNotSupportedException);
    }
 
    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707:IdentifiersShouldNotContainUnderscores", MessageId = "Member"), EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void DataPortal_OnDataPortalInvoke(DataPortalEventArgs e)
    {
 
    }
 
    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707:IdentifiersShouldNotContainUnderscores", MessageId = "Member"), EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void DataPortal_OnDataPortalInvokeComplete(DataPortalEventArgs e)
    {
 
    }
 
    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707:IdentifiersShouldNotContainUnderscores", MessageId = "Member"), EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void DataPortal_OnDataPortalException(DataPortalEventArgs e, Exception ex)
    {
 
    }
 
    #endregion
 
    #region ToArray
 
    public T[] ToArray()
    {
      List<T> result = new List<T>();
      foreach (T item in this)
        result.Add(item);
      return result.ToArray();
    }
 
    #endregion
 
    #region IDataPortalTarget Members
 
    void Csla.Server.IDataPortalTarget.CheckRules()
    { }
 
    void Csla.Server.IDataPortalTarget.MarkAsChild()
    { }
 
    void Csla.Server.IDataPortalTarget.MarkNew()
    { }
 
    void Csla.Server.IDataPortalTarget.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)
    { }
 
    void Csla.Server.IDataPortalTarget.Child_OnDataPortalInvokeComplete(DataPortalEventArgs e)
    { }
 
    void Csla.Server.IDataPortalTarget.Child_OnDataPortalException(DataPortalEventArgs e, Exception ex)
    { }
 
    #endregion
 
    #region Mobile object overrides
 
    protected override void OnGetState(SerializationInfo info)
    {
      info.AddValue("Csla.Core.BusinessBase._identity", _identity);
      base.OnGetState(info);
    }
 
    protected override void OnSetState(SerializationInfo info)
    {
      _identity = info.GetValue<int>("Csla.Core.BusinessBase._identity");
      base.OnSetState(info);
    }
 
    #endregion
  }
}