SerializationInfo.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="SerializationInfo.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Object containing the serialization</summary>
//-----------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Linq;
using System.Runtime.Serialization;
 
namespace Csla.Serialization.Mobile
{
#if TESTING
  [System.Diagnostics.DebuggerNonUserCode]
#endif
  [Serializable]
  [DataContract]
  public class SerializationInfo : IMobileObject
  {
    [Serializable]
    [DataContract]
    public class FieldData : IMobileObject
    {
      [DataMember]
      public object Value { get; set; }
 
      [DataMember]
      public string EnumTypeName { get; set; }
 
      [DataMember]
      public bool IsDirty { get; set; }
 
      #region IMobileObject Members
 
      public FieldData() { }
 
      public void GetState(SerializationInfo info)
      {
        info.AddValue("FieldData.Value", Value);
        info.AddValue("FieldData.EnumTypeName", EnumTypeName);
        info.AddValue("FieldData.IsDirty", IsDirty);
      }
 
      public void GetChildren(SerializationInfo info, MobileFormatter formatter)
      {
      }
 
      public void SetState(SerializationInfo info)
      {
        Value = info.GetValue<object>("FieldData.Value");
        EnumTypeName = info.GetValue<string>("FieldData.EnumTypeName");
        IsDirty = info.GetValue<bool>("FieldData.IsDirty");
      }
 
      public void SetChildren(SerializationInfo info, MobileFormatter formatter)
      {
      }
 
      #endregion
    }
 
    [Serializable]
    [DataContract]
    public class ChildData : IMobileObject
    {
      [DataMember]
      public int ReferenceId { get; set; }
      [DataMember]
      public bool IsDirty { get; set; }
 
      #region IMobileObject Members
 
      public ChildData() { }
 
      public void GetState(SerializationInfo info)
      {
        info.AddValue("ChildData.ReferenceId", ReferenceId);
        info.AddValue("ChildData.IsDirty", IsDirty);
      }
 
      public void GetChildren(SerializationInfo info, MobileFormatter formatter)
      {
      }
 
      public void SetState(SerializationInfo info)
      {
        ReferenceId = info.GetValue<int>("ChildData.ReferenceId");
        IsDirty = info.GetValue<bool>("ChildData.IsDirty");
      }
 
      public void SetChildren(SerializationInfo info, MobileFormatter formatter)
      {
      }
 
      #endregion
    }
 
    private Dictionary<string, ChildData> _children = new Dictionary<string, ChildData>();
    [DataMember()]
    public Dictionary<string, ChildData> Children
    {
      get { return _children; }
      set { _children = value; }
    }
 
    private Dictionary<string, FieldData> _values = new Dictionary<string, FieldData>();
    [DataMember()]
    public Dictionary<string, FieldData> Values
    {
      get { return _values; }
      set { _values = value; }
    }
 
    internal SerializationInfo(int referenceId)
    {
      this.ReferenceId = referenceId;
    }
 
    [DataMember]
    public int ReferenceId { get; set; }
    [DataMember]
    public string TypeName { get; set; }
 
    public void AddValue(string name, object value)
    {
      AddValue(name, value, false);
    }
 
    public void AddValue(string name, object value, bool isDirty)
    {
      _values.Add(name, new FieldData { Value = value, IsDirty = isDirty });
    }
 
    public void AddValue(string name, object value, bool isDirty, string enumTypeName)
    {
      _values.Add(name, new FieldData { Value = value, IsDirty = isDirty, EnumTypeName = enumTypeName});
    }
 
    public T GetValue<T>(string name)
    {
      try
      {
        var value = _values[name].Value;
        return (value != null ? (T)Utilities.CoerceValue<T>(value.GetType(), null, value) : (T)value);
      }
      catch (Exception ex)
      {
        throw new InvalidOperationException(string.Format("SerializationInfo.GetValue: {0}", name), ex);
      }
    }
 
    public void AddChild(string name, int referenceId)
    {
      AddChild(name, referenceId, false);
    }
 
    public void AddChild(string name, int referenceId, bool isDirty)
    {
      _children.Add(name, new ChildData { ReferenceId = referenceId, IsDirty = isDirty });
    }
 
    #region IMobileObject Members
 
    public SerializationInfo() { }
 
    public void GetState(SerializationInfo info)
    {
      info.AddValue("SerializationInfo.ReferenceId", ReferenceId);
      info.AddValue("SerializationInfo.TypeName", TypeName);
    }
 
    public void GetChildren(SerializationInfo info, MobileFormatter formatter)
    {
      foreach (string key in _children.Keys)
      {
        ChildData value = _children[key];
        SerializationInfo si = formatter.SerializeObject(value);
        info.AddChild(key, si.ReferenceId);
      }
      foreach (string key in _values.Keys)
      {
        FieldData value = _values[key];
        SerializationInfo si = formatter.SerializeObject(value);
        info.AddChild(key, si.ReferenceId);
      }
    }
 
    public void SetState(SerializationInfo info)
    {
      ReferenceId = info.GetValue<int>("SerializationInfo.ReferenceId");
      TypeName = info.GetValue<string>("SerializationInfo.TypeName");
    }
 
    public void SetChildren(SerializationInfo info, MobileFormatter formatter)
    {
      foreach (string key in info.Children.Keys)
      {
        int referenceId = info.Children[key].ReferenceId;
        object serialized = formatter.GetObject(referenceId);
        if (serialized is ChildData)
        {
          _children.Add(key, (ChildData)serialized);
        }
        else
        {
          _values.Add(key, (FieldData)serialized);
        }
      }
    }
 
    #endregion
  }
}