MobileBindingList.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="MobileBindingList.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Inherit from this base class to easily</summary>
//-----------------------------------------------------------------------
using System;
using System.ComponentModel;
using System.Collections.Generic;
using Csla.Serialization.Mobile;
using Csla.Properties;
using System.Reflection;
using Csla.Reflection;
using System.Diagnostics;
 
namespace Csla.Core
{
#if TESTING
  [System.Diagnostics.DebuggerStepThrough]
#endif
  [Serializable]
  public class MobileBindingList<T> : BindingList<T>, IMobileList
  {
    #region LoadListMode
 
    [NonSerialized]
    [NotUndoable]
    private LoadListModeObject _loadListModeObject = null;
 
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    protected LoadListModeObject LoadListMode
    {
      get
      {
        if (_loadListModeObject == null)
        {
          _loadListModeObject = new LoadListModeObject(this);
          SetLoadListMode(true);
        }
        return _loadListModeObject;
      }
    }
    void IMobileList.SetLoadListMode(bool enabled)
    {
      _loadListModeObject = null;
      SetLoadListMode(enabled);
      if (_oldRLCE == null)
        _oldRLCE = new Stack<bool>();
      if (enabled)
      {
        _oldRLCE.Push(RaiseListChangedEvents);
        RaiseListChangedEvents = false;
      }
      else
      {
        if (_oldRLCE.Count > 0)
          RaiseListChangedEvents = _oldRLCE.Pop();
      }
    }
 
    [NonSerialized]
    [NotUndoable]
    private Stack<bool> _oldRLCE;
 
    protected virtual void SetLoadListMode(bool enabled)
    {
    }
 
    [EditorBrowsable(EditorBrowsableState.Never)]
#pragma warning disable CA1063 // Implement IDisposable Correctly
    protected class LoadListModeObject : IDisposable
#pragma warning restore CA1063 // Implement IDisposable Correctly
    {
      private readonly IMobileList _target;
      public LoadListModeObject(IMobileList target)
      {
        _target = target;
        _target.SetLoadListMode(true);
      }
 
#pragma warning disable CA1063 // Implement IDisposable Correctly
      public void Dispose()
#pragma warning restore CA1063 // Implement IDisposable Correctly
      {
        _target.SetLoadListMode(false);
        GC.SuppressFinalize(this);
      }
    }
 
    #endregion
 
    #region IMobileObject Members
 
    void IMobileObject.GetChildren(SerializationInfo info, MobileFormatter formatter)
    {
      OnGetChildren(info, formatter);
    }
 
    void IMobileObject.GetState(SerializationInfo info)
    {
      OnGetState(info);
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void OnGetState(SerializationInfo info)
    {
      info.AddValue("Csla.Core.MobileList.AllowEdit", AllowEdit);
      info.AddValue("Csla.Core.MobileList.AllowNew", AllowNew);
      info.AddValue("Csla.Core.MobileList.AllowRemove", AllowRemove);
      info.AddValue("Csla.Core.MobileList.RaiseListChangedEvents", RaiseListChangedEvents);
#if (ANDROID || IOS) || NETFX_CORE
      info.AddValue("Csla.Core.MobileList._supportsChangeNotificationCore", SupportsChangeNotificationCore);
#endif
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void OnGetChildren(SerializationInfo info, MobileFormatter formatter)
    {
      if (!typeof(IMobileObject).IsAssignableFrom(typeof(T)))
        throw new InvalidOperationException(Resources.CannotSerializeCollectionsNotOfIMobileObject);
 
      List<int> references = new List<int>();
      for (int x = 0; x < this.Count; x++)
      {
        T child = this[x];
        if (child != null)
        {
          SerializationInfo childInfo = formatter.SerializeObject(child);
          references.Add(childInfo.ReferenceId);
        }
      }
      if (references.Count > 0)
        info.AddValue("$list", references);
    }
 
    void IMobileObject.SetState(SerializationInfo info)
    {
      OnSetState(info);
    }
 
    void IMobileObject.SetChildren(SerializationInfo info, MobileFormatter formatter)
    {
      OnSetChildren(info, formatter);
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void OnSetState(SerializationInfo info)
    {
      AllowEdit = info.GetValue<bool>("Csla.Core.MobileList.AllowEdit");
      AllowNew = info.GetValue<bool>("Csla.Core.MobileList.AllowNew");
      AllowRemove = info.GetValue<bool>("Csla.Core.MobileList.AllowRemove");
      RaiseListChangedEvents = info.GetValue<bool>("Csla.Core.MobileList.RaiseListChangedEvents");
    }
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void OnSetChildren(SerializationInfo info, MobileFormatter formatter)
    {
      if (!typeof(IMobileObject).IsAssignableFrom(typeof(T)))
        throw new InvalidOperationException(Resources.CannotSerializeCollectionsNotOfIMobileObject);
 
      bool originalRaiseListChangedEvents = this.RaiseListChangedEvents;
 
      try
      {
        this.RaiseListChangedEvents = false;
 
        if (info.Values.ContainsKey("$list"))
        {
          List<int> references = (List<int>)info.Values["$list"].Value;
          foreach (int reference in references)
          {
            T child = (T)formatter.GetObject(reference);
            this.Add(child);
          }
        }
      }
      finally
      {
          this.RaiseListChangedEvents = originalRaiseListChangedEvents;
      }
    }
 
    #endregion
  }
}