/// <summary>
/// Deserialize an object from a byte array
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="bytes"></param>
/// <param name="options">The serialization options</param>
/// <param name="typeMaps">A list of type mappings</param>
/// <returns></returns>
public object Deserialize(Type type, byte[] bytes, SerializerOptions options, params SerializationTypeMap[] typeMaps)
{
if (bytes == null)
{
throw new ArgumentNullException(nameof(bytes));
}
if (bytes.Length == 0)
{
return(null);
}
SerializationTypeRegistry typeRegistry = null;
if (typeMaps != null && typeMaps.Length > 0)
{
SerializationTypeRegistry.Configure((config) =>
{
foreach (var typeMap in typeMaps)
{
config.Mappings.Add(typeMap);
}
});
}
return(Deserialize(type, bytes, options, typeRegistry));
}
/// <summary>
/// Configure a new type registry
/// </summary>
/// <param name="config"></param>
/// <returns></returns>
public static SerializationTypeRegistry Configure(Action <SerializationTypeRegistry> config)
{
var registry = new SerializationTypeRegistry();
config(registry);
return(registry);
}
/// <summary>
/// Deserialize an object from a byte array
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="bytes"></param>
/// <param name="options">The serialization options</param>
/// <param name="typeRegistry">A list of type mappings</param>
/// <returns></returns>
public T Deserialize <T>(byte[] bytes, SerializerOptions options, SerializationTypeRegistry typeRegistry)
{
if (bytes == null)
{
throw new ArgumentNullException(nameof(bytes));
}
if (bytes.Length == 0)
{
return(default(T));
}
return(_deserializer.InspectAndDeserialize <T>(bytes, Constants.DefaultMaxDepth, options, _ignoreAttributes, typeRegistry));
}
private TypeRegistry ConvertToTypeRegistry(SerializationTypeRegistry typeRegistry)
{
if (typeRegistry == null)
{
return(null);
}
var registry = TypeRegistry.Configure(c => {
foreach (var factory in typeRegistry.Factories)
{
var newFactory = _objectFactory.CreateEmptyObject <TypeFactory>(factory.Source, factory.Factory);
c.Factories.Add(newFactory);
}
foreach (var map in typeRegistry.Mappings)
{
var newMap = _objectFactory.CreateEmptyObject <TypeMap>();
newMap.Source = map.Source;
newMap.Destination = map.Destination;
c.Mappings.Add(newMap);
}
});
return(registry);
}
/// <summary>
/// Inspect a type and deserialize its contents
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sourceExtendedType"></param>
/// <param name="sourceBytes"></param>
/// <param name="maxDepth"></param>
/// <param name="options">The serialization options</param>
/// <param name="ignoreAttributes"></param>
/// <param name="typeRegistry">Custom type registry</param>
/// <returns></returns>
internal object InspectAndDeserialize(Type type, byte[] sourceBytes, uint maxDepth, SerializerOptions options, ICollection <object> ignoreAttributes, SerializationTypeRegistry typeRegistry = null, ICollection <string> ignorePropertiesOrPaths = null)
{
if (sourceBytes == null)
{
return(null);
}
using (var stream = new MemoryStream(sourceBytes))
{
using (var reader = new BinaryReader(stream))
{
var obj = TypeReader.Read(reader, type.GetExtendedType(), maxDepth, options, ignoreAttributes, typeRegistry, ignorePropertiesOrPaths);
return(obj);
}
}
}
/// <summary>
/// Inspect a type and deserialize its contents
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sourceBytes"></param>
/// <param name="maxDepth"></param>
/// <param name="options">The serialization options</param>
/// <param name="ignoreAttributes"></param>
/// <param name="typeRegistry">Custom type registry</param>
/// <returns></returns>
internal T InspectAndDeserialize <T>(byte[] sourceBytes, uint maxDepth, SerializerOptions options, ICollection <object> ignoreAttributes, SerializationTypeRegistry typeRegistry = null, ICollection <string> ignorePropertiesOrPaths = null)
{
return((T)InspectAndDeserialize(typeof(T), sourceBytes, maxDepth, options, ignoreAttributes, typeRegistry, ignorePropertiesOrPaths));
}
public TypeReader(SerializerDataSettings dataSettings, SerializerOptions options, uint maxDepth, ICollection <object> ignoreAttributes, SerializationTypeRegistry typeRegistry, ICollection <string> ignorePropertiesOrPaths = null)
{
_dataSettings = dataSettings;
_options = options;
_maxDepth = maxDepth;
_ignoreAttributes = ignoreAttributes;
_ignorePropertiesOrPaths = ignorePropertiesOrPaths;
_typeRegistry = ConvertToTypeRegistry(typeRegistry);
_objectReferences = new Dictionary <ushort, object>();
_customSerializers = new Dictionary <Type, Lazy <ICustomSerializer> >
{
{ typeof(Point), new Lazy <ICustomSerializer>(() => new PointSerializer()) },
{ typeof(Enum), new Lazy <ICustomSerializer>(() => new EnumSerializer()) },
{ typeof(XDocument), new Lazy <ICustomSerializer>(() => new XDocumentSerializer()) },
};
}
/// <summary>
/// Read the parent object, and recursively process it's children
/// </summary>
/// <param name="reader"></param>
/// <param name="typeSupport">The type of the root object</param>
/// <param name="maxDepth">The max depth tree to process</param>
/// <param name="options">The serialization options</param>
/// <param name="objectTree">Tracks the tree that has been traversed</param>
/// <param name="ignoreAttributes">Properties/Fields with these attributes will be ignored from processing</param>
/// <param name="typeRegistry">A registry that contains custom type mappings</param>
/// <returns></returns>
internal static object Read(BinaryReader reader, ExtendedType typeSupport, uint maxDepth, SerializerOptions options, ICollection <object> ignoreAttributes, SerializationTypeRegistry typeRegistry = null, ICollection <string> ignorePropertiesOrPaths = null)
{
var currentDepth = 0;
uint dataLength = 0;
uint headerLength = 0;
var dataReader = reader;
// read in byte 0, the data settings
var dataSettings = (SerializerDataSettings)reader.ReadByte();
if (dataSettings.BitwiseHasFlag(SerializerDataSettings.Compress))
{
// decompress the stream
dataReader = Decompress(reader);
}
var typeReader = new TypeReader(dataSettings, options, maxDepth, ignoreAttributes, typeRegistry, ignorePropertiesOrPaths);
return(typeReader.ReadObject(dataReader, typeSupport, currentDepth, string.Empty, ref dataLength, ref headerLength));
}
/// <summary>
/// Deserialize an object from a byte array
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="bytes"></param>
/// <param name="typeRegistry">A list of type mappings</param>
/// <returns></returns>
public object Deserialize(Type type, byte[] bytes, SerializationTypeRegistry typeRegistry)
{
return(Deserialize(type, bytes, SerializerOptions.None, typeRegistry));
}
/// <summary>
/// Deserialize an object from a byte array
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="bytes"></param>
/// <param name="typeRegistry">A list of type mappings</param>
/// <returns></returns>
public T Deserialize <T>(byte[] bytes, SerializationTypeRegistry typeRegistry)
{
return(Deserialize <T>(bytes, SerializerOptions.None, typeRegistry));
}
/// <summary>
/// Deserialize an object of type <typeparamref name="T"/>
/// </summary>
/// <typeparam name="T">The type to deserialize</typeparam>
/// <param name="bytes"></param>
/// <param name="options">The serializer options</param>
/// <param name="typeRegistry">A list of type mappings</param>
/// <returns>Deserlized <typeparamref name="T"/></returns>
public static T Deserialize <T>(byte[] bytes, SerializerOptions options, SerializationTypeRegistry typeRegistry)
{
return(Extensions.SerializerExtensions.Deserialize <T>(bytes, options, typeRegistry));
}
