DynamicBindingListBase.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="DynamicBindingListBase.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.ComponentModel;
using Csla.Core;
using Csla.Serialization.Mobile;
 
namespace Csla
{
  [Serializable()]
  public abstract class DynamicBindingListBase<T> :
    Core.ExtendedBindingList<T>,
    Core.IParent,
    Server.IDataPortalTarget,
    IBusinessObject
    where T : Core.IEditableBusinessObject, Core.IUndoableObject, Core.ISavable, IMobileObject, IBusinessObject
    {
    public DynamicBindingListBase()
    {
      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)
    {
      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
 
    private bool _activelySaving;
 
    public T SaveItem(T item)
    {
      return SaveItem(IndexOf(item));
    }
 
    public virtual T SaveItem(int index)
    {
      bool raisingEvents = this.RaiseListChangedEvents;
      this.RaiseListChangedEvents = false;
      _activelySaving = true;
 
      T item = default(T);
      T result = default(T);
      try
      {
        item = this[index];
        result = item;
        T savable = item;
 
        // clone the object if possible
        ICloneable clonable = savable as ICloneable;
        if (clonable != null)
          savable = (T)clonable.Clone();
 
        // commit all changes
        int editLevel = savable.EditLevel;
        for (int tmp = 1; tmp <= editLevel; tmp++)
          savable.AcceptChanges(editLevel - tmp, false);
 
        // do the save
        result = (T)savable.Save();
 
        if (!ReferenceEquals(result, item))
        {
          // restore edit level to previous level
          for (int tmp = 1; tmp <= editLevel; tmp++)
            result.CopyState(tmp, false);
 
          // put result into collection
          this[index] = result;
        }
 
        if (!ReferenceEquals(savable, item))
        {
          // raise Saved event from original object
          Core.ISavable original = item as Core.ISavable;
          if (original != null)
            original.SaveComplete(result);
        }
 
        OnSaved(result, null);
      }
      finally
      {
        _activelySaving = false;
        this.RaiseListChangedEvents = raisingEvents;
      }
      this.OnListChanged(new ListChangedEventArgs(ListChangedType.ItemChanged, index));
      return result;
    }
 
#endregion
 
#region Saved Event
    [NonSerialized]
    [NotUndoable]
    private EventHandler<Csla.Core.SavedEventArgs> _nonSerializableSavedHandlers;
    [NotUndoable]
    private EventHandler<Csla.Core.SavedEventArgs> _serializableSavedHandlers;
 
    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design",
      "CA1062:ValidateArgumentsOfPublicMethods")]
    public event EventHandler<Csla.Core.SavedEventArgs> Saved
    {
      add
      {
        if (value.Method.IsPublic &&
           (value.Method.DeclaringType.IsSerializable ||
            value.Method.IsStatic))
          _serializableSavedHandlers = (EventHandler<Csla.Core.SavedEventArgs>)
            System.Delegate.Combine(_serializableSavedHandlers, value);
        else
          _nonSerializableSavedHandlers = (EventHandler<Csla.Core.SavedEventArgs>)
            System.Delegate.Combine(_nonSerializableSavedHandlers, value);
      }
      remove
      {
        if (value.Method.IsPublic &&
           (value.Method.DeclaringType.IsSerializable ||
            value.Method.IsStatic))
          _serializableSavedHandlers = (EventHandler<Csla.Core.SavedEventArgs>)
            System.Delegate.Remove(_serializableSavedHandlers, value);
        else
          _nonSerializableSavedHandlers = (EventHandler<Csla.Core.SavedEventArgs>)
            System.Delegate.Remove(_nonSerializableSavedHandlers, value);
      }
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void OnSaved(T newObject, Exception e)
    {
      Csla.Core.SavedEventArgs args = new Csla.Core.SavedEventArgs(newObject, e, null);
      if (_nonSerializableSavedHandlers != null)
        _nonSerializableSavedHandlers.Invoke(this, args);
      if (_serializableSavedHandlers != null)
        _serializableSavedHandlers.Invoke(this, args);
    }
 
#endregion
 
#region  Insert, Remove, Clear
 
    protected override object AddNewCore()
    {
      T item = Csla.DataPortal.Create<T>();
      Add(item);
      this.OnAddingNew(new AddingNewEventArgs(item));
      return item;
    }
 
    protected override void InsertItem(int index, T item)
    {
      item.SetParent(this);
      base.InsertItem(index, item);
    }
 
    protected override void RemoveItem(int index)
    {
      // delete item from database
      T item = this[index];
 
      // only delete/save the item if it is not new
      bool raiseEventForNewItem = false;
      if (!item.IsNew)
      {
        item.Delete();
        SaveItem(index);
      }
      else
      {
        raiseEventForNewItem = true;
      }
 
      base.RemoveItem(index);
      if (raiseEventForNewItem)
        OnSaved(item, null);
    }
 
    protected override void SetItem(int index, T item)
    {
      item.SetParent(this);
      base.SetItem(index, item);
    }
 
#endregion
 
#region  IParent Members
 
    void Csla.Core.IParent.ApplyEditChild(Core.IEditableBusinessObject child)
    {
      if (!_activelySaving && child.EditLevel == 0)
        SaveItem((T)child);
    }
 
    void Csla.Core.IParent.RemoveChild(Core.IEditableBusinessObject child)
    {
      if (child.IsNew)
        Remove((T)child);
    }
 
    IParent Csla.Core.IParent.Parent
    {
      get { return null; }
    }
 
#endregion
 
#region  Cascade Child events
 
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected override void Child_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
    {
      for (int index = 0; index < this.Count; index++)
      {
        if (ReferenceEquals(this[index], sender))
        {
          PropertyDescriptor descriptor = GetPropertyDescriptor(e.PropertyName);
          if (descriptor != null)
            OnListChanged(new ListChangedEventArgs(
              ListChangedType.ItemChanged, index, GetPropertyDescriptor(e.PropertyName)));
          else
            OnListChanged(new ListChangedEventArgs(
              ListChangedType.ItemChanged, index));
          return;
        }
      }
      OnChildPropertyChanged(sender, e);
      base.Child_PropertyChanged(sender, e);
    }
 
    void Child_BusyChanged(object sender, BusyChangedEventArgs e)
    {
      OnBusyChanged(e);
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void OnChildPropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
    { }
 
    private static PropertyDescriptorCollection _propertyDescriptors;
 
    private PropertyDescriptor GetPropertyDescriptor(string propertyName)
    {
      if (_propertyDescriptors == null)
        _propertyDescriptors = TypeDescriptor.GetProperties(this.GetType());
      PropertyDescriptor result = null;
      foreach (PropertyDescriptor desc in _propertyDescriptors)
        if (desc.Name == propertyName)
        {
          result = desc;
          break;
        }
      return result;
    }
 
#endregion
 
#region  Serialization Notification
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected override void OnDeserialized()
    {
      foreach (IEditableBusinessObject child in this)
      {
        child.SetParent(this);
        INotifyPropertyChanged c = child as INotifyPropertyChanged;
        if (c != null)
          c.PropertyChanged += new PropertyChangedEventHandler(Child_PropertyChanged);
      }
      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 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 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
  }
}