MobileFormatter.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="SerializationFormatterFactory.GetFormatter().cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Serializes and deserializes objects</summary>
//-----------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Serialization;
using Csla.Properties;
using Csla.Reflection;
 
namespace Csla.Serialization.Mobile
{
#if TESTING
  [System.Diagnostics.DebuggerStepThrough]
#endif
  public sealed class MobileFormatter : ISerializationFormatter
  {
    #region Serialize
 
    public void Serialize(Stream serializationStream, object graph)
    {
      ICslaWriter writer = CslaReaderWriterFactory.GetCslaWriter();
      writer.Write(serializationStream, SerializeToDTO(graph));
    }
 
    byte[] ISerializationFormatter.Serialize(object graph)
    {
      using var buffer = new MemoryStream();
      Serialize(buffer, graph);
      buffer.Position = 0;
      return buffer.ToArray();
    }
 
    public List<SerializationInfo> SerializeAsDTO(object graph)
    {
      _serializationReferences.Clear();
 
      SerializeObject(graph);
 
      ConvertEnumsToIntegers();
      List<SerializationInfo> serialized = _serializationReferences.Values.ToList();
 
      return serialized;
    }
 
    private void ConvertEnumsToIntegers()
    {
      foreach (SerializationInfo serializationInfo in _serializationReferences.Values)
      {
        foreach (SerializationInfo.FieldData fieldData in serializationInfo.Values.Values)
        {
          if (fieldData.Value != null)
          {
            Type fieldType = fieldData.Value.GetType();
 
            if (fieldType.IsEnum)
            {
              fieldData.Value = Convert.ChangeType(fieldData.Value, Enum.GetUnderlyingType(fieldType));
              fieldData.EnumTypeName = fieldType.AssemblyQualifiedName;
            }
          }
        }
      }
    }
 
    public SerializationInfo SerializeObject(object obj)
    {
      SerializationInfo info;
      if (obj == null)
      {
        NullPlaceholder nullPlaceholder = new NullPlaceholder();
 
        info = new SerializationInfo(_serializationReferences.Count + 1);
        _serializationReferences.Add(nullPlaceholder, info);
 
        info.TypeName = AssemblyNameTranslator.GetAssemblyQualifiedName(typeof(NullPlaceholder));
      }
      else
      {
        var thisType = obj.GetType();
        if (obj is System.Security.Claims.ClaimsPrincipal cp)
        {
          obj = new Security.CslaClaimsPrincipal(cp);
          thisType = obj.GetType();
        }
        if (!thisType.IsSerializable)
          throw new InvalidOperationException(
            string.Format(Resources.ObjectNotSerializableFormatted, thisType.FullName));
        if (!(obj is IMobileObject mobile))
          throw new InvalidOperationException(
            string.Format(Resources.MustImplementIMobileObject,
            thisType.Name));
 
        if (!_serializationReferences.TryGetValue(mobile, out info))
        {
          info = new SerializationInfo(_serializationReferences.Count + 1);
          _serializationReferences.Add(mobile, info);
 
          info.TypeName = AssemblyNameTranslator.GetAssemblyQualifiedName(thisType);
          if (thisType.Equals(typeof(Security.CslaClaimsPrincipal)))
          {
            var principal = (Security.CslaClaimsPrincipal)obj;
            using (var buffer = new System.IO.MemoryStream())
            {
              using (var writer = new System.IO.BinaryWriter(buffer))
              {
                principal.WriteTo(writer);
                info.AddValue("s", buffer.ToArray());
              }
            }
          }
          else
          {
            mobile.GetChildren(info, this);
            mobile.GetState(info);
          }
        }
      }
      return info;
    }
 
    private Dictionary<IMobileObject, SerializationInfo> _serializationReferences =
      new Dictionary<IMobileObject, SerializationInfo>(new ReferenceComparer<IMobileObject>());
 
#endregion
 
#region Deserialize
 
    private Dictionary<int, IMobileObject> _deserializationReferences =
      new Dictionary<int, IMobileObject>();
 
    private Dictionary<string, Type> _typeCache = new Dictionary<string, Type>();
 
    private Type GetTypeFromCache(string typeName)
    {
      Type result;
      if (!_typeCache.TryGetValue(typeName, out result))
      {
        result = Csla.Reflection.MethodCaller.GetType(typeName);
 
        if (result == null)
        {
          throw new SerializationException(string.Format(
            Resources.MobileFormatterUnableToDeserialize,
            typeName));
        }
        _typeCache.Add(typeName, result);
      }
 
      return result;
    }
 
    public object Deserialize(Stream serializationStream)
    {
      if (serializationStream == null)
        return null;
 
      ICslaReader reader = CslaReaderWriterFactory.GetCslaReader();
      var data = reader.Read(serializationStream);
      return DeserializeAsDTO(data);
    }
 
    object ISerializationFormatter.Deserialize(byte[] buffer)
    {
      if (buffer.Length == 0)
        return null;
      using var serializationStream = new MemoryStream(buffer);
      ICslaReader reader = CslaReaderWriterFactory.GetCslaReader();
      var data = reader.Read(serializationStream);
      return DeserializeAsDTO(data);
    }
 
    public object DeserializeAsDTO(List<SerializationInfo> deserialized)
    {
 
      _deserializationReferences = new Dictionary<int, IMobileObject>();
      foreach (SerializationInfo info in deserialized)
      {
        var typeName = AssemblyNameTranslator.GetAssemblyQualifiedName(info.TypeName);
        Type type = GetTypeFromCache(typeName);
 
        if (type == null)
        {
          throw new SerializationException(string.Format(
            Resources.MobileFormatterUnableToDeserialize, typeName));
        }
        else if (type == typeof(NullPlaceholder))
        {
          _deserializationReferences.Add(info.ReferenceId, null);
        }
        else
        {
          if (type.Equals(typeof(Security.CslaClaimsPrincipal)))
          {
            var state = info.GetValue<byte[]>("s");
            using (var buffer = new System.IO.MemoryStream(state))
            {
              using (var reader = new System.IO.BinaryReader(buffer))
              {
                IMobileObject mobile = (IMobileObject)new Security.CslaClaimsPrincipal(reader);
                _deserializationReferences.Add(info.ReferenceId, mobile);
              }
            }
          }
          else
          {
            IMobileObject mobile = (IMobileObject)Activator.CreateInstance(type);
 
            _deserializationReferences.Add(info.ReferenceId, mobile);
 
            ConvertEnumsFromIntegers(info);
            mobile.SetState(info);
          }
        }
      }
 
      foreach (SerializationInfo info in deserialized)
      {
        IMobileObject mobile = _deserializationReferences[info.ReferenceId];
 
        if (mobile != null)
        {
          mobile.SetChildren(info, this);
        }
      }
 
      foreach (SerializationInfo info in deserialized)
      {
        ISerializationNotification notifiable = _deserializationReferences[info.ReferenceId] as ISerializationNotification;
        if (notifiable != null)
          notifiable.Deserialized();
      }
      return (_deserializationReferences.Count > 0 ? _deserializationReferences[1] : null);
    }
 
    private static void ConvertEnumsFromIntegers(SerializationInfo serializationInfo)
    {
      foreach (SerializationInfo.FieldData fieldData in serializationInfo.Values.Values)
      {
        if (!String.IsNullOrEmpty(fieldData.EnumTypeName))
        {
          Type enumType = MethodCaller.GetType(fieldData.EnumTypeName);
          fieldData.Value = Enum.ToObject(enumType, fieldData.Value);
        }
      }
    }
 
    public IMobileObject GetObject(int referenceId)
    {
      return _deserializationReferences[referenceId];
    }
 
#endregion
 
#region Static Helpers
 
    public static byte[] Serialize(object obj)
    {
      using (var buffer = new System.IO.MemoryStream())
      {
        var formatter = new MobileFormatter();
        formatter.Serialize(buffer, obj);
        return buffer.ToArray();
      }
    }
 
    public static List<SerializationInfo> SerializeToDTO(object obj)
    {
      var formatter = new MobileFormatter();
      return formatter.SerializeAsDTO(obj);
    }
 
    public static object DeserializeFromDTO(List<SerializationInfo> serialized)
    {
      var formatter = new MobileFormatter();
      return formatter.DeserializeAsDTO(serialized);
    }
 
    public static object Deserialize(byte[] data)
    {
      if (data == null)
        return null;
 
      using (var buffer = new System.IO.MemoryStream(data))
      {
        var formatter = new MobileFormatter();
        return formatter.Deserialize(buffer);
      }
    }
 
    public static object Deserialize(List<SerializationInfo> data)
    {
      if (data == null)
        return null;
 
      var formatter = new MobileFormatter();
      return formatter.DeserializeAsDTO(data);
    }
#endregion
 
  }
}