Marc Hernandez
3f850cc9b0
- Introduced XmlSer class for XML serialization and deserialization. - Added TypeMetaCache for caching type metadata and reflection information. - Implemented various ITypeHandler implementations for handling different types (Primitive, Proxy, ISerializable, Collection, Object). - Enhanced type resolution with TypeResolver to manage type lookups and conversions. - Established a configuration class (XmlCfg) to manage serialization settings. - Integrated support for handling graphs and references in serialized objects. - Added extensive member processing and filtering based on attributes. - Ensured compatibility with immutable collections and various data structures. - Implemented detailed error handling and logging for serialization processes.
1506 lines
36 KiB
C#
1506 lines
36 KiB
C#
|
|
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Xml;
|
|
using System.Runtime.Serialization;
|
|
//using System.Web.Configuration;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
|
|
|
|
using System.Reflection;
|
|
using System.Diagnostics;
|
|
|
|
using System.Linq;
|
|
using System.Collections.Immutable;
|
|
using System.Net.Sockets;
|
|
|
|
|
|
/*
|
|
|
|
element and attribute names
|
|
- Element names are case-sensitive
|
|
- Element names must start with a letter or underscore
|
|
- Element names cannot start with the letters xml(or XML, or Xml, etc)
|
|
- Element names can contain letters, digits, hyphens, underscores, and periods
|
|
- Element names cannot contain spaces
|
|
|
|
* TODO
|
|
* x) Add the ability for correctly named attributes to be able to fill in classes
|
|
* x)
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
namespace lib
|
|
{
|
|
|
|
public interface I_Serialize
|
|
{
|
|
void OnSerialize() {}
|
|
object OnDeserialize( object enclosing ) => this;
|
|
}
|
|
|
|
|
|
[Flags]
|
|
public enum Types
|
|
{
|
|
Fields = 0b_0001,
|
|
Props = 0b_0010,
|
|
Implied = 0b_0100,
|
|
Explicit = 0b_1000,
|
|
|
|
|
|
None = 0b_0000,
|
|
Default = Fields,
|
|
All = Fields | Props,
|
|
}
|
|
|
|
public class Ser : Attribute
|
|
{
|
|
public Types Types { get; set; } = Types.Default;
|
|
}
|
|
|
|
public class Do : Attribute
|
|
{
|
|
}
|
|
|
|
public class Dont : Attribute
|
|
{
|
|
}
|
|
|
|
public class ChildAttribute : Attribute
|
|
{
|
|
public string[] Values { get; private set; }
|
|
|
|
public ChildAttribute( params string[] values )
|
|
{
|
|
this.Values = values;
|
|
}
|
|
}
|
|
|
|
public class ChildFieldsAttribute : ChildAttribute
|
|
{
|
|
public ChildFieldsAttribute( params string[] values ) : base( values ) { }
|
|
}
|
|
|
|
public class ChildPropsAttribute : ChildAttribute
|
|
{
|
|
public ChildPropsAttribute( params string[] values ) : base( values ) { }
|
|
}
|
|
|
|
public enum Datastructure
|
|
{
|
|
Invalid,
|
|
|
|
// Breaks on circular datastructures since it will go on forever
|
|
Tree,
|
|
|
|
// Works for everything.
|
|
Graph,
|
|
|
|
}
|
|
|
|
public record struct TypeProxy( Func<object, string> ser, Func<string, string, object> des );
|
|
|
|
//public record struct CollectionCreator( Func<IEnumerable, object> FnCreate );
|
|
|
|
//These 2 enums are for serialization
|
|
public enum BackingFieldNaming
|
|
{
|
|
Invalid,
|
|
Short, //Use the prop name
|
|
Regular,
|
|
}
|
|
|
|
public enum POD
|
|
{
|
|
Invalid,
|
|
Attributes,
|
|
Elements,
|
|
}
|
|
|
|
|
|
public class XmlFormatter2Cfg : Config
|
|
{
|
|
public bool VerboseLogging = false;
|
|
|
|
public Datastructure datastructure = Datastructure.Tree;
|
|
|
|
public int Version = 2;
|
|
|
|
public Dictionary<string, List<string>> WLProps = new();
|
|
public Dictionary<string, List<string>> WLFields = new();
|
|
|
|
public Dictionary<Type, TypeProxy> TypeProxy = new();
|
|
|
|
//public Dictionary<Type, CollectionCreator> CollectionCreator = new();
|
|
//For Serialization
|
|
public BackingFieldNaming Naming = BackingFieldNaming.Short;
|
|
public POD POD = POD.Attributes;
|
|
|
|
public Types TypesDefault = Types.Fields;
|
|
}
|
|
|
|
public class XmlFormatter2 : IFormatter
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public StreamingContext Context { get; set; }
|
|
|
|
private XmlFormatter2Cfg _cfg = new();
|
|
|
|
#region Unimplimented
|
|
public ISurrogateSelector SurrogateSelector
|
|
{
|
|
get { throw new NotImplementedException(); }
|
|
set { throw new NotImplementedException(); }
|
|
}
|
|
|
|
public SerializationBinder Binder
|
|
{
|
|
get { throw new NotImplementedException(); }
|
|
set { throw new NotImplementedException(); }
|
|
}
|
|
#endregion
|
|
|
|
|
|
public XmlFormatter2()
|
|
{
|
|
//Context = new StreamingContext( StreamingContextStates.All );
|
|
}
|
|
|
|
public XmlFormatter2( XmlFormatter2Cfg cfg )
|
|
{
|
|
//Context = new StreamingContext( StreamingContextStates.All );
|
|
|
|
_cfg = cfg;
|
|
|
|
log.high( $"XML serialization is NOT fast" );
|
|
}
|
|
|
|
#region Deserialize
|
|
private static FormatterConverter s_conv = new();
|
|
|
|
private string fromStr = "";
|
|
|
|
void SetFromStr( Stream stream )
|
|
{
|
|
fromStr = stream.ToString() ?? "{null}";
|
|
|
|
if( stream is FileStream fs )
|
|
{
|
|
fromStr = fs.Name;
|
|
}
|
|
|
|
if( stream is NetworkStream ns )
|
|
{
|
|
fromStr = ns?.Socket?.RemoteEndPoint?.ToString() ?? $"{ns}";
|
|
}
|
|
}
|
|
|
|
public object Deserialize( Stream stream )
|
|
{
|
|
SetFromStr( stream );
|
|
var obj = DeserializeKnownType( stream, null );
|
|
return obj;
|
|
}
|
|
|
|
|
|
public T? Deserialize<T>( Stream stream ) => (T)DeserializeKnownType( stream, typeof( T ) );
|
|
|
|
public object? DeserializeKnownType( Stream stream, Type? t )
|
|
{
|
|
SetFromStr( stream );
|
|
|
|
XmlTextReader reader = new( stream );
|
|
|
|
object? obj = Deserialize( reader, t );
|
|
|
|
return obj;
|
|
}
|
|
|
|
private object? Deserialize( XmlReader reader, Type? t )
|
|
{
|
|
m_alreadySerialized.Clear();
|
|
m_objectID = new ObjectIDGenerator();
|
|
|
|
reader.Read();
|
|
|
|
XmlDocument doc = new XmlDocument();
|
|
|
|
doc.Load( reader );
|
|
|
|
if( doc.DocumentElement == null ) return null;
|
|
|
|
if( t == null )
|
|
return Deserialize( doc.DocumentElement );
|
|
|
|
return Deserialize( doc.DocumentElement, null, t, null );
|
|
}
|
|
|
|
public void DeserializeInto<T>( Stream stream, T obj )
|
|
{
|
|
SetFromStr( stream );
|
|
|
|
XmlTextReader reader = new( stream );
|
|
reader.Read();
|
|
|
|
XmlDocument doc = new();
|
|
|
|
doc.Load( reader );
|
|
|
|
HydrateObject<T>( doc.DocumentElement, null, obj );
|
|
}
|
|
|
|
private object Deserialize( XmlElement elem )
|
|
{
|
|
//lib.log.info( "object Deserialize( XmlElement elem ) {0} {1}", m_rndVal, m_alreadySerialized.Count );
|
|
|
|
string typename = elem.HasAttribute( "_.t" ) ? elem.GetAttribute( "_.t" ) : elem.Name;
|
|
|
|
return Deserialize( elem, null, typename );
|
|
}
|
|
|
|
private object Deserialize( XmlElement elem, MemberInfo mi, string typename )
|
|
{
|
|
AppDomain currentDomain = AppDomain.CurrentDomain;
|
|
Assembly[] assems = currentDomain.GetAssemblies();
|
|
|
|
Type type = null;
|
|
|
|
// @@@@: This should go backwards, we tend to lookup our own stuff, then builtins.
|
|
// Also, cache a typename into its assembly.
|
|
foreach( Assembly a in assems )
|
|
{
|
|
type = a.GetType( typename );
|
|
|
|
if( type != null )
|
|
break;
|
|
}
|
|
|
|
if( type == null )
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return Deserialize( elem, null, type, null );
|
|
}
|
|
|
|
static private bool IsEnumerable( Type type ) => type.IsAssignableTo( typeof( IEnumerable ) );
|
|
|
|
private object Deserialize( XmlElement elem, MemberInfo? mi, Type type, object? existing /*, object enclosing = null*/ )
|
|
{
|
|
var name = mi?.Name ?? "{NOT_FOUND}";
|
|
return Deserialize( elem, mi, type, name, existing );
|
|
}
|
|
|
|
private object Deserialize( XmlElement elem, MemberInfo? mi, Type type, string name, object? existing /*, object enclosing = null*/ )
|
|
{
|
|
try
|
|
{
|
|
TypeCode typeCode = Type.GetTypeCode( type );
|
|
|
|
if( _cfg.VerboseLogging ) log.info( $"{type.FriendlyName()}.{name} {existing} {mi?.Name}" );
|
|
|
|
if( typeCode != TypeCode.Object )
|
|
{
|
|
return DeserializeConcrete( elem, mi, name, type );
|
|
}
|
|
else
|
|
{
|
|
if( !type.IsArray )
|
|
{
|
|
if( IsEnumerable( type ) )
|
|
{
|
|
return DeserializeCollection( elem, mi, type );
|
|
}
|
|
else
|
|
{
|
|
object obj = DeserializeObject( elem, mi, type, existing );
|
|
|
|
if( obj is I_Serialize iser )
|
|
{
|
|
if( _cfg.VerboseLogging ) log.info( $"" );
|
|
obj = iser.OnDeserialize( null );
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return DeserializeArray( elem, mi, type );
|
|
}
|
|
}
|
|
}
|
|
catch( Exception ex )
|
|
{
|
|
log.warn( $"Caught exception fn {mi?.Name} type {type?.FriendlyName()} of {ex.Message}" );
|
|
}
|
|
|
|
return existing;
|
|
}
|
|
|
|
private object GetDefault( Type t )
|
|
{
|
|
var types = new Type[1];
|
|
types[0] = t;
|
|
|
|
var fn = GetType().GetMethod( "GetDefaultGeneric" ).MakeGenericMethod( types );
|
|
|
|
return fn.Invoke( this, null );
|
|
}
|
|
|
|
static public T GetDefaultGeneric<T>()
|
|
{
|
|
return default( T );
|
|
}
|
|
|
|
private object DeserializeConcrete( XmlElement elem, MemberInfo mi, string name, Type type )
|
|
{
|
|
if( _cfg.VerboseLogging ) log.info( $"" );
|
|
|
|
string val = "";
|
|
|
|
if( elem.HasAttribute( "v" ) )
|
|
{
|
|
val = elem.GetAttribute( "v" );
|
|
}
|
|
else if( elem.HasAttribute( name ) )
|
|
{
|
|
val = elem.GetAttribute( name );
|
|
}
|
|
else
|
|
{
|
|
val = elem.InnerText;
|
|
}
|
|
|
|
if( !type.IsEnum )
|
|
{
|
|
try
|
|
{
|
|
return s_conv.Convert( val, type );
|
|
}
|
|
catch( Exception )
|
|
{
|
|
return GetDefault( type );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return Enum.Parse( type, val );
|
|
}
|
|
|
|
}
|
|
|
|
private XmlElement getNamedChild( XmlNodeList list, string name )
|
|
{
|
|
foreach( XmlNode node in list )
|
|
{
|
|
if( node.Name == name )
|
|
{
|
|
return (XmlElement)node;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private Type FindType( string shortname )
|
|
{
|
|
Assembly[] ass = AppDomain.CurrentDomain.GetAssemblies();
|
|
|
|
foreach( Assembly a in ass )
|
|
{
|
|
Type t = a.GetType( shortname );
|
|
|
|
if( t != null )
|
|
{
|
|
return t;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private Type[] mm_consType = new Type[2];
|
|
private object[] mm_args = new object[2];
|
|
|
|
private object DeserializeObject( XmlElement elem, MemberInfo mi, Type type, object existing )
|
|
{
|
|
Type finalType;
|
|
|
|
var obj = GetObjectForDeser( elem, type, out finalType, existing );
|
|
|
|
return HydrateObject( elem, mi, finalType, obj );
|
|
}
|
|
|
|
public object HydrateObject<T>( XmlElement elem, MemberInfo mi, T obj )
|
|
{
|
|
return HydrateObject( elem, mi, typeof( T ), obj );
|
|
}
|
|
|
|
private object HydrateObject( XmlElement elem, MemberInfo mi, Type finalType, object obj )
|
|
{
|
|
if( _cfg.VerboseLogging ) log.info( $"" );
|
|
|
|
if( obj is IList )
|
|
{
|
|
var list = obj as IList;
|
|
|
|
return DeserializeList( elem, mi, finalType, list );
|
|
}
|
|
|
|
Type typeISerializable = typeof( ISerializable );
|
|
|
|
if( obj is ISerializable ) // type.IsSubclassOf( typeISerializable ) )
|
|
{
|
|
XmlNodeList allChildren = elem.ChildNodes;
|
|
|
|
//ISerializable ser = obj as ISerializable;
|
|
|
|
var serInfo = new SerializationInfo( finalType, new FormatterConverter() );
|
|
|
|
//var serInfoForTypes = new SerializationInfo( type, new FormatterConverter() );
|
|
|
|
//ser.GetObjectData( serInfoForTypes, Context );
|
|
|
|
foreach( var objNode in allChildren )
|
|
{
|
|
var node = objNode as XmlElement;
|
|
|
|
string name = node.Name;
|
|
|
|
string childType = node.GetAttribute( "_.t" );
|
|
|
|
name = refl.TypeToIdentifier( name );
|
|
|
|
XmlElement childElem = getNamedChild( allChildren, name );
|
|
|
|
var des = Deserialize( childElem, mi, childType );
|
|
|
|
serInfo.AddValue( name, des, des.GetType() );
|
|
}
|
|
|
|
//ConstructorInfo[] allCons = obj.GetType().GetConstructors( BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic );
|
|
|
|
//var serMem = FormatterServices.GetSerializableMembers( finalType );
|
|
|
|
//object objUn = FormatterServices.GetSafeUninitializedObject( finalType );
|
|
|
|
var objUnOnDeser = obj as IDeserializationCallback;
|
|
|
|
mm_consType[0] = typeof( SerializationInfo );
|
|
mm_consType[1] = typeof( StreamingContext );
|
|
ConstructorInfo serCons = finalType.GetConstructor( BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, mm_consType, null );
|
|
|
|
var context = new StreamingContext( StreamingContextStates.File, obj );
|
|
|
|
mm_args[0] = serInfo;
|
|
mm_args[1] = context;
|
|
serCons.Invoke( obj, mm_args );
|
|
|
|
if( objUnOnDeser != null )
|
|
{
|
|
objUnOnDeser.OnDeserialization( objUnOnDeser );
|
|
}
|
|
|
|
/*
|
|
ser.GetObjectData( serInfo, Context );
|
|
|
|
//var serEnum = ;
|
|
|
|
foreach( var serMember in serInfo )
|
|
{
|
|
string name = serMember.Name;
|
|
|
|
name = refl.TypeToIdentifier( name );
|
|
|
|
XmlElement childElem = getNamedChild( allChildren, name );
|
|
|
|
var des = Deserialize( childElem, name );
|
|
}
|
|
*/
|
|
}
|
|
else
|
|
{
|
|
HydrateObjectOfNarrowType( elem, mi, finalType, obj );
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
private object HydrateObjectOfNarrowType( XmlElement elem, MemberInfo mi, Type narrowType, object obj )
|
|
{
|
|
if( _cfg.VerboseLogging ) log.info( $"" );
|
|
|
|
var isImm = typeof(imm.Obj).IsAssignableFrom( narrowType );
|
|
|
|
XmlNodeList allChildren = elem.ChildNodes;
|
|
|
|
bool filterFields, filterProps, doImpls, doFields, doProps;
|
|
HashSet<string> whitelistFields, whitelistProps;
|
|
GetFilters( _cfg.TypesDefault, mi, narrowType, out filterFields, out filterProps, out doImpls, out doFields, out doProps, out whitelistFields, out whitelistProps );
|
|
|
|
if( doFields || doImpls )
|
|
{
|
|
var fields = refl.GetAllFields( narrowType );
|
|
|
|
foreach( FieldInfo childFi in fields )
|
|
{
|
|
|
|
string name = childFi.Name;
|
|
|
|
var dontAtt = childFi.GetCustomAttributes<lib.Dont>();
|
|
var doAtt = childFi.GetCustomAttributes<lib.Do>();
|
|
|
|
string propName = "";
|
|
|
|
if( name.StartsWith( "<" ) && name.EndsWith( "BackingField" ) )
|
|
{
|
|
var gtIndex = name.IndexOf( '>' );
|
|
|
|
propName = name.Substring( 1, gtIndex - 1 );
|
|
|
|
var propInfo = narrowType.GetProperty( propName );
|
|
|
|
dontAtt = propInfo.GetCustomAttributes<lib.Dont>();
|
|
|
|
doAtt = propInfo.GetCustomAttributes<lib.Do>();
|
|
}
|
|
|
|
if( dontAtt.Any() )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//if( name.EndsWith( ) )
|
|
|
|
//This is to convert c# names that would be bad as XML tags
|
|
name = refl.TypeToIdentifier( name );
|
|
|
|
// @@@ TODO This doesnt yet handle propNames!
|
|
if( !doAtt.Any() && FilterField( filterFields, doImpls, whitelistFields, childFi as MemberInfo, name ) )
|
|
continue;
|
|
|
|
var useFieldName = true;
|
|
//Get the value from an attribute named after the field
|
|
string attValue = elem.GetAttribute( name );
|
|
|
|
//Now, if we dont have one, grab one from the property name
|
|
if( !string.IsNullOrWhiteSpace( propName ) && string.IsNullOrWhiteSpace( attValue ) )
|
|
{
|
|
useFieldName = false;
|
|
attValue = elem.GetAttribute( propName );
|
|
}
|
|
|
|
if( !string.IsNullOrWhiteSpace( attValue ) )
|
|
{
|
|
object existingObj = childFi.GetValue( obj );
|
|
|
|
object childObj = DeserializeConcrete( elem, childFi, useFieldName ? name : propName, childFi.FieldType );
|
|
|
|
childFi.SetValue( obj, childObj );
|
|
}
|
|
else
|
|
{
|
|
XmlElement childElem = getNamedChild( allChildren, name );
|
|
if( childElem == null && !string.IsNullOrWhiteSpace( propName ) )
|
|
childElem = getNamedChild( allChildren, propName );
|
|
|
|
if( childElem != null )
|
|
{
|
|
object existingObj = childFi.GetValue( obj );
|
|
|
|
object childObj = Deserialize( childElem, childFi, childFi.FieldType, existingObj );
|
|
|
|
childFi.SetValue( obj, childObj );
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
if( doProps || doImpls )
|
|
{
|
|
var props = refl.GetAllProperties( narrowType );
|
|
|
|
foreach( var childPi in props )
|
|
{
|
|
string name = childPi.Name;
|
|
var dontAtt = childPi.GetCustomAttributes<lib.Dont>();
|
|
if( dontAtt.Any() )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var doAtt = childPi.GetCustomAttributes<lib.Do>();
|
|
|
|
|
|
name = refl.TypeToIdentifier( name );
|
|
|
|
if( !doAtt.Any() && FilterField( filterProps, doImpls, whitelistProps, childPi as PropertyInfo, name ) )
|
|
continue;
|
|
|
|
XmlElement childElem = getNamedChild( allChildren, name );
|
|
|
|
var setMethod = childPi.GetSetMethod();
|
|
|
|
if( childElem != null )
|
|
{
|
|
object existingObj = childPi.GetValue( obj );
|
|
|
|
object childObj = Deserialize( childElem, childPi, childPi.PropertyType, existingObj );
|
|
|
|
if( setMethod != null )
|
|
{
|
|
//Object o = Activator.CreateInstance( setMethod.ReflectedType );
|
|
setMethod.Invoke( obj, new object[] { childObj } );
|
|
|
|
//setMethod.CreateDelegate()
|
|
}
|
|
else
|
|
{
|
|
childPi.SetValue( obj, childObj );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
object existingObj = childPi.GetValue( obj );
|
|
|
|
object childObj = DeserializeConcrete( elem, childPi, name, childPi.PropertyType );
|
|
|
|
if( setMethod != null )
|
|
{
|
|
//Object o = Activator.CreateInstance( setMethod.ReflectedType );
|
|
setMethod.Invoke( obj, new object[] { childObj } );
|
|
|
|
//setMethod.CreateDelegate()
|
|
}
|
|
else
|
|
{
|
|
childPi.SetValue( obj, childObj );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!isImm)
|
|
{
|
|
return obj;
|
|
}
|
|
else
|
|
{
|
|
var imm = obj as imm.Obj;
|
|
var newObj = imm.Record( $"From XML {fromStr}:{elem.ParentNode?.Name}{elem.Name}" );
|
|
return newObj;
|
|
}
|
|
|
|
}
|
|
|
|
private static bool FilterField( bool filterFields, bool doImpls, HashSet<string> whitelistFields, MemberInfo mi, string name )
|
|
{
|
|
if( doImpls )
|
|
{
|
|
if( mi.GetCustomAttribute<ChildAttribute>( true ) == null )
|
|
return true;
|
|
}
|
|
|
|
if( filterFields && !whitelistFields.Contains( name ) )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
private object GetObjectForDeser( XmlElement elem, Type type, out Type finalType, object obj )
|
|
{
|
|
|
|
finalType = type;
|
|
if( elem.HasAttribute( "_.t" ) )
|
|
{
|
|
var typename = elem.GetAttribute( "_.t" );
|
|
finalType = FindType( typename );
|
|
|
|
if( finalType == null )
|
|
finalType = type;
|
|
}
|
|
|
|
string refString = elem.GetAttribute( "ref" );
|
|
|
|
int refInt = refString.Length > 0 ? Convert.ToInt32( refString ) : -1;
|
|
|
|
if( _cfg.VerboseLogging ) log.info( $"{finalType?.FriendlyName()}({type?.FriendlyName()}) refInt {refInt} exitingObj = {obj?.ToString()}" );
|
|
|
|
obj = createObject( elem, finalType, refInt, obj );
|
|
|
|
return obj;
|
|
}
|
|
|
|
private object DeserializeList( XmlElement elem, MemberInfo mi, Type type, IList list )
|
|
{
|
|
if( _cfg.VerboseLogging ) log.info( $"" );
|
|
|
|
XmlNodeList arrNodeList = elem.ChildNodes;
|
|
|
|
Type t = list.GetType();
|
|
|
|
Type[] genT = t.GetGenericArguments();
|
|
|
|
Debug.Assert( genT.Length == 1 );
|
|
|
|
for( int i = 0; i < arrNodeList.Count; ++i )
|
|
{
|
|
if( arrNodeList.Item( i ) is XmlElement )
|
|
{
|
|
XmlElement arrElem = (XmlElement)arrNodeList.Item( i );
|
|
|
|
list.Add( Deserialize( arrElem, mi, genT[0], null ) );
|
|
}
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
private object DeserializeCollection( XmlElement elem, MemberInfo mi, Type type )
|
|
{
|
|
Type typeElem = typeof( object );
|
|
|
|
if( type.GenericTypeArguments.Length == 1 )
|
|
{
|
|
typeElem = type.GenericTypeArguments[0];
|
|
}
|
|
else if( type.GenericTypeArguments.Length == 2 )
|
|
{
|
|
typeElem = typeof( KeyValuePair<,> ).MakeGenericType( type.GenericTypeArguments );
|
|
}
|
|
|
|
if( _cfg.VerboseLogging ) log.info( $"DserCol {type.GetType().FriendlyName()} {typeElem.Name} into reflT {mi.ReflectedType.FriendlyName()} declT {mi.DeclaringType.FriendlyName()} {mi.Name}" );
|
|
|
|
string refString = elem.GetAttribute( "ref" );
|
|
int refInt = refString.Length > 0 ? Convert.ToInt32( refString ) : -1;
|
|
|
|
XmlNodeList arrNodeList = elem.ChildNodes;
|
|
|
|
int length = arrNodeList.Count;
|
|
|
|
Array arr = createArray( typeElem, refInt, length );
|
|
|
|
for( int i = 0; i < arr.Length; ++i )
|
|
{
|
|
if( arrNodeList.Item( i ) is XmlElement )
|
|
{
|
|
XmlElement arrElem = (XmlElement)arrNodeList.Item( i );
|
|
|
|
var finalType = typeElem;
|
|
if( arrElem.HasAttribute( "_.t" ) )
|
|
{
|
|
var typename = arrElem.GetAttribute( "_.t" );
|
|
finalType = FindType( typename );
|
|
|
|
if( finalType == null )
|
|
finalType = typeElem;
|
|
}
|
|
|
|
var arrItem = Deserialize( arrElem, mi, finalType, null );
|
|
|
|
arr.SetValue( arrItem, i );
|
|
}
|
|
}
|
|
|
|
var listType = ( typeof( List<> ) ).MakeGenericType( typeElem );
|
|
IList list = Activator.CreateInstance( listType ) as IList;
|
|
|
|
foreach( var a in arr )
|
|
{
|
|
list.Add( a );
|
|
}
|
|
|
|
MethodInfo? toMeth = null;
|
|
|
|
var typeGen = Type.MakeGenericSignatureType( type );
|
|
|
|
if( _cfg.VerboseLogging ) log.info( $"TypeGen: {typeGen.FriendlyName()}" );
|
|
|
|
if( type == typeof( ImmutableArray<> ).MakeGenericType( typeElem ) )
|
|
{
|
|
var genMeth = GetType().GetMethod( "MakeImmutableArray", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic );
|
|
toMeth = genMeth.MakeGenericMethod( typeElem );
|
|
}
|
|
else if( type == typeof( ImmutableDictionary<,> ).MakeGenericType( typeElem.GenericTypeArguments ) )
|
|
{
|
|
var genMeth = GetType().GetMethod( "MakeImmutableDictionary", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic );
|
|
toMeth = genMeth.MakeGenericMethod( typeElem.GenericTypeArguments );
|
|
}
|
|
else if( type == typeof( List<> ).MakeGenericType( typeElem ) )
|
|
{
|
|
var genMeth = GetType().GetMethod( "MakeList", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic );
|
|
toMeth = genMeth.MakeGenericMethod( typeElem );
|
|
}
|
|
else if( type == typeof( Dictionary<,> ).MakeGenericType( typeElem.GenericTypeArguments ) )
|
|
{
|
|
var genMeth = GetType().GetMethod( "MakeDictionary", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic );
|
|
toMeth = genMeth.MakeGenericMethod( typeElem.GenericTypeArguments );
|
|
}
|
|
|
|
|
|
var obj = toMeth?.Invoke( this, new object[1] { list } );
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
private List<T> MakeList<T>( IList list )
|
|
{
|
|
return list as List<T>;
|
|
}
|
|
|
|
private object MakeImmutableArray<T>( List<T> list )
|
|
{
|
|
var arr = list.ToImmutableArray();
|
|
return arr;
|
|
}
|
|
|
|
private object MakeImmutableDictionary<K, V>( List<KeyValuePair<K, V>> list )
|
|
{
|
|
var dict = list.ToImmutableDictionary();
|
|
return dict;
|
|
}
|
|
|
|
|
|
private object MakeDictionary<K, V>( List<KeyValuePair<K, V>> list )
|
|
{
|
|
var dict = list.ToDictionary();
|
|
return dict;
|
|
}
|
|
|
|
|
|
private object DeserializeArray( XmlElement elem, MemberInfo mi, Type type )
|
|
{
|
|
if( _cfg.VerboseLogging ) log.info( $"" );
|
|
|
|
Type typeElem = type.GetElementType();
|
|
|
|
string refString = elem.GetAttribute( "ref" );
|
|
int refInt = refString.Length > 0 ? Convert.ToInt32( refString ) : -1;
|
|
|
|
XmlNodeList arrNodeList = elem.ChildNodes;
|
|
|
|
int length = arrNodeList.Count;
|
|
|
|
Array arr = createArray( typeElem, refInt, length );
|
|
|
|
for( int i = 0; i < arr.Length; ++i )
|
|
{
|
|
if( arrNodeList.Item( i ) is XmlElement )
|
|
{
|
|
XmlElement arrElem = (XmlElement)arrNodeList.Item( i );
|
|
|
|
var finalType = typeElem;
|
|
if( arrElem.HasAttribute( "_.t" ) )
|
|
{
|
|
var typename = arrElem.GetAttribute( "_.t" );
|
|
finalType = FindType( typename );
|
|
|
|
if( finalType == null )
|
|
finalType = typeElem;
|
|
}
|
|
|
|
arr.SetValue( Deserialize( arrElem, mi, finalType, null ), i );
|
|
}
|
|
}
|
|
|
|
return arr;
|
|
}
|
|
|
|
private object createObject( XmlElement elem, string typename, int refInt, object obj )
|
|
{
|
|
Type type = Type.GetType( typename );
|
|
|
|
return createObject( elem, type, refInt, obj );
|
|
}
|
|
|
|
private object createObject( XmlElement elem, Type type, int refInt, object existingObj )
|
|
{
|
|
|
|
TypeCode tc = Type.GetTypeCode( type );
|
|
|
|
if( _cfg.datastructure == Datastructure.Graph && refInt > 0 && m_alreadySerialized.ContainsKey( refInt ) )
|
|
{
|
|
if( _cfg.VerboseLogging ) log.info( $"Reuse object" );
|
|
return m_alreadySerialized[refInt];
|
|
}
|
|
|
|
// FIRST If there is a proxy deserializer, we skip using the existing object.
|
|
|
|
var isProxy = elem.HasAttribute( "proxy" );
|
|
|
|
if( isProxy )
|
|
{
|
|
if( _cfg.VerboseLogging ) log.info( $"use Proxy" );
|
|
object obj = null;
|
|
|
|
var tryType = type;
|
|
TypeProxy? proxy = null;
|
|
|
|
while( tryType != typeof( object ) && obj == null )
|
|
{
|
|
//m_cfg.TypeProxy.TryGetValue( )
|
|
if( _cfg.TypeProxy.TryGetValue( tryType, out var newProxy ) )
|
|
{
|
|
proxy = newProxy;
|
|
break;
|
|
}
|
|
|
|
tryType = tryType.BaseType;
|
|
}
|
|
|
|
var proxyVal = elem.GetAttribute( "proxy" );
|
|
|
|
if( proxy.HasValue )
|
|
{
|
|
obj = proxy.Value.des( type.Name, proxyVal );
|
|
|
|
return obj;
|
|
}
|
|
else
|
|
{
|
|
log.warn( $"Trying to proxy in {elem.Name}, but there is no proxy available. Falling back to regular hydrate/create" );
|
|
}
|
|
}
|
|
|
|
// SECOND if we have an existing object there of the same type, replace
|
|
|
|
if( existingObj != null )
|
|
{
|
|
var existingObjType = existingObj.GetType();
|
|
|
|
//var isSubclass = type.IsSubclassOf( existingObjType ) || existingObjType.IsSubclassOf( type );
|
|
var isSubclass = type.IsAssignableFrom( existingObjType );
|
|
|
|
|
|
if( isSubclass )
|
|
{
|
|
if( _cfg.VerboseLogging ) log.info( $"Using existing obj {existingObj?.ToString()}" );
|
|
return existingObj;
|
|
}
|
|
|
|
// old
|
|
//if( type == existingObjType ) return existingObj;
|
|
}
|
|
|
|
|
|
|
|
// THIRD create a new object
|
|
{
|
|
object obj = null;
|
|
|
|
try
|
|
{
|
|
if( _cfg.VerboseLogging ) log.info( $"For {type.FriendlyName()} check for constructors" );
|
|
|
|
var cons = type.GetConstructor( Type.EmptyTypes );
|
|
if( cons != null)
|
|
{
|
|
if( _cfg.VerboseLogging ) log.info( $"Activator.CreateInstance" );
|
|
obj = Activator.CreateInstance( type );
|
|
}
|
|
else
|
|
{
|
|
log.debug( $"For {type.FriendlyName()} use GetUninitializedObject" );
|
|
obj = System.Runtime.Serialization.FormatterServices.GetUninitializedObject( type );
|
|
}
|
|
|
|
if( _cfg.VerboseLogging ) log.info( $"Got obj {obj?.ToString()}" );
|
|
}
|
|
catch( Exception )
|
|
{
|
|
try
|
|
{
|
|
if( _cfg.VerboseLogging ) log.info( $"GetUninitializedObject" );
|
|
obj = System.Runtime.Serialization.FormatterServices.GetUninitializedObject( type );
|
|
if( _cfg.VerboseLogging ) log.info( $"Got obj {obj?.ToString()}" );
|
|
}
|
|
catch( Exception exInner )
|
|
{
|
|
log.error( $"Got exception {exInner.Message} trying to make an uninitialized object" );
|
|
}
|
|
}
|
|
|
|
if( obj == null )
|
|
{
|
|
log.warn( $"Could not create object of type {type.FriendlyName()}" );
|
|
|
|
return obj;
|
|
}
|
|
|
|
if( _cfg.datastructure == Datastructure.Graph && refInt > 0 )
|
|
{
|
|
m_alreadySerialized[refInt] = obj;
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
}
|
|
|
|
private Array createArray( string elemTypename, int refInt, int length )
|
|
{
|
|
Type elemType = Type.GetType( elemTypename );
|
|
|
|
return createArray( elemType, refInt, length );
|
|
}
|
|
|
|
private Array createArray( Type elemType, int refInt, int length )
|
|
{
|
|
TypeCode elemTC = Type.GetTypeCode( elemType );
|
|
|
|
if( _cfg.datastructure == Datastructure.Graph && refInt > 0 && m_alreadySerialized.ContainsKey( refInt ) )
|
|
{
|
|
return (Array)m_alreadySerialized[refInt];
|
|
}
|
|
else
|
|
{
|
|
Array arr = Array.CreateInstance( elemType, length );
|
|
|
|
if( _cfg.datastructure == Datastructure.Graph )
|
|
{
|
|
m_alreadySerialized[refInt] = arr;
|
|
|
|
}
|
|
|
|
return arr;
|
|
}
|
|
}
|
|
|
|
private ObjectIDGenerator m_objectID = new ObjectIDGenerator();
|
|
private Dictionary<long, object> m_alreadySerialized = new Dictionary<long, object>();
|
|
|
|
#endregion
|
|
|
|
#region Serialize
|
|
|
|
private string getTypeName( Type type )
|
|
{
|
|
//Assembly ass = type.Assembly;
|
|
|
|
//string assName = ass.GetName().FriendlyName();
|
|
|
|
return type.FullName; // + ", " + assName;
|
|
}
|
|
|
|
public void Serialize( Stream stream, object root )
|
|
{
|
|
Serialize( stream, null, typeof( object ), root );
|
|
}
|
|
|
|
public void Serialize( Stream stream, MemberInfo mi, Type mType, object root )
|
|
{
|
|
//lib.log.info( "Serialize( Stream stream, object root ) {0} {1}", m_rndVal, m_alreadySerialized.Count );
|
|
|
|
m_alreadySerialized.Clear();
|
|
m_objectID = new ObjectIDGenerator();
|
|
|
|
XmlTextWriter writer = new XmlTextWriter( stream, System.Text.Encoding.ASCII );
|
|
|
|
writer.Formatting = Formatting.Indented;
|
|
|
|
Serialize( writer, mi, mType, root );
|
|
|
|
//Rely on the parent closing the stream.
|
|
//writer.Close();
|
|
writer.Flush();
|
|
|
|
//lib.log.info( "Serialize END ( Stream stream, object root ) {0} {1}", m_rndVal, m_alreadySerialized.Count );
|
|
}
|
|
|
|
private void Serialize( XmlWriter writer, MemberInfo mi, Type mType, object root )
|
|
{
|
|
//writer.WriteStartDocument();
|
|
Serialize( writer, mi, mType, root, "root", 1, true );
|
|
//writer.WriteEndDocument();
|
|
}
|
|
|
|
private void Serialize( XmlWriter writer, MemberInfo mi, Type mType, object root, string name, int depth, bool forceType )
|
|
{
|
|
if( root != null )
|
|
{
|
|
Type type = root.GetType();
|
|
|
|
TypeCode typeCode = Type.GetTypeCode( type );
|
|
|
|
if( typeCode != TypeCode.Object )
|
|
{
|
|
bool writeELements = _cfg.POD == POD.Elements || forceType;
|
|
|
|
if( !writeELements && writer is XmlTextWriter textWriter )
|
|
{
|
|
var writeState = textWriter.WriteState;
|
|
|
|
writeELements = writeState != WriteState.Element;
|
|
}
|
|
|
|
if( writeELements )
|
|
writer.WriteStartElement( name );
|
|
|
|
SerializeConcrete( writer, mi, root, name, forceType );
|
|
|
|
if( writeELements )
|
|
writer.WriteEndElement();
|
|
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
writer.WriteStartElement( name );
|
|
if( !type.IsArray )
|
|
{
|
|
if( IsEnumerable( type ) )
|
|
{
|
|
SerializeCollection( writer, mi, mType, root, depth );
|
|
}
|
|
else
|
|
{
|
|
SerializeObject( writer, mi, mType, root, depth );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SerializeArray( writer, mi, mType, root, depth );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
writer.WriteStartElement( name );
|
|
|
|
writer.WriteAttributeString( "v", "null" );
|
|
}
|
|
|
|
writer.WriteEndElement();
|
|
}
|
|
|
|
private void SerializeConcrete( XmlWriter writer, MemberInfo mi, object root, string name, bool forceType )
|
|
{
|
|
//TODO: Only write this out if debugging.
|
|
if( forceType || _cfg.POD == POD.Elements )
|
|
{
|
|
if( forceType )
|
|
writer.WriteAttributeString( "_.t", getTypeName( root.GetType() ) );
|
|
|
|
writer.WriteAttributeString( "v", root.ToString() );
|
|
}
|
|
else
|
|
{
|
|
writer.WriteAttributeString( name, root.ToString() );
|
|
}
|
|
}
|
|
|
|
private void SerializeCollection( XmlWriter writer, MemberInfo? mi, Type mType, object root, int depth )
|
|
{
|
|
IEnumerable it = root as IEnumerable;
|
|
|
|
//Array arr = (Array)root;
|
|
|
|
Type typeElem = it.GetType().GenericTypeArguments[0];
|
|
|
|
Type type = root.GetType();
|
|
|
|
if( mType != type )
|
|
{
|
|
log.info( $"Coll: {mType.FriendlyName()} {mi?.Name} != {type.FriendlyName()}" );
|
|
writer.WriteAttributeString( "_.t", getTypeName( type ) );
|
|
}
|
|
|
|
bool first;
|
|
|
|
long refInt = m_objectID.GetId( root, out first );
|
|
|
|
if( _cfg.datastructure == Datastructure.Graph )
|
|
{
|
|
writer.WriteAttributeString( "ref", refInt.ToString() );
|
|
}
|
|
|
|
if( first )
|
|
{
|
|
if( _cfg.datastructure == Datastructure.Graph )
|
|
{
|
|
m_alreadySerialized[refInt] = root;
|
|
}
|
|
|
|
int i = 0;
|
|
foreach( var v in it )
|
|
{
|
|
Serialize( writer, null, typeElem, v, "i" + i.ToString(), depth + 1, false );
|
|
++i;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
private void SerializeObject( XmlWriter writer, MemberInfo mi, Type mType, object root, int depth )
|
|
{
|
|
if( mType != root.GetType() )
|
|
{
|
|
var rType = root.GetType();
|
|
var rTypeName = !rType.IsNested ? rType.Name : $"{rType.DeclaringType.Name}.{rType.Name}";
|
|
var mTypeName = !mType.IsNested ? mType.Name : $"{mType.DeclaringType.Name}.{mType.Name}";
|
|
var rootTypeName = !mType.IsNested ? mType.Name : $"{mType.DeclaringType.Name}.{mType.Name}";
|
|
log.info( $"SerObj {mTypeName} != {rTypeName}" );
|
|
writer.WriteAttributeString( "_.t", getTypeName( root.GetType() ) );
|
|
}
|
|
|
|
if( depth == 1 )
|
|
{
|
|
writer.WriteAttributeString( "_.version.", $"{_cfg.Version}" );
|
|
}
|
|
|
|
long refInt = m_objectID.GetId( root, out var first );
|
|
|
|
// @@@@ FIX for proxies.
|
|
if( _cfg.datastructure == Datastructure.Graph )
|
|
{
|
|
writer.WriteAttributeString( "ref", refInt.ToString() );
|
|
}
|
|
|
|
if( first )
|
|
{
|
|
if( _cfg.datastructure == Datastructure.Graph )
|
|
{
|
|
m_alreadySerialized[refInt] = root;
|
|
}
|
|
|
|
Type type = root.GetType();
|
|
|
|
//*
|
|
Type typeISerializable = typeof( ISerializable );
|
|
|
|
if( root is ISerializable ser )
|
|
{
|
|
if( root is Delegate )
|
|
{
|
|
return;
|
|
}
|
|
|
|
var serInfo = new SerializationInfo( type, new FormatterConverter() );
|
|
|
|
var context = new StreamingContext( StreamingContextStates.File, root );
|
|
|
|
ser.GetObjectData( serInfo, context );
|
|
|
|
foreach( var serMember in serInfo )
|
|
{
|
|
string name = serMember.Name;
|
|
|
|
name = refl.TypeToIdentifier( name );
|
|
|
|
Serialize( writer, mi, mType, serMember.Value, name, depth, true );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
{
|
|
var tryType = type;
|
|
TypeProxy? proxy = null;
|
|
|
|
while( tryType != typeof( object ) )
|
|
{
|
|
if( _cfg.TypeProxy.TryGetValue( tryType, out var newProxy ) )
|
|
{
|
|
proxy = newProxy;
|
|
break;
|
|
}
|
|
|
|
tryType = tryType.BaseType;
|
|
}
|
|
|
|
if( proxy.HasValue )
|
|
{
|
|
var proxyStr = proxy.Value.ser( root );
|
|
writer.WriteAttributeString( "proxy", proxyStr );
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
//*/
|
|
SerializeObjectOfNarrowType( writer, mi, root, depth, type );
|
|
}
|
|
}
|
|
|
|
private void SerializeObjectOfNarrowType( XmlWriter writer, MemberInfo mi, object root, int depth, Type narrowType )
|
|
{
|
|
bool filterFields, filterProps, doImpls, doFields, doProps;
|
|
HashSet<string> whitelistFields, whitelistProps;
|
|
GetFilters( _cfg.TypesDefault, mi, narrowType, out filterFields, out filterProps, out doImpls, out doFields, out doProps, out whitelistFields, out whitelistProps );
|
|
|
|
var isImm = typeof(imm.Obj).IsAssignableFrom( narrowType );
|
|
|
|
if( doFields || doImpls )
|
|
{
|
|
var fields = refl.GetAllFields( narrowType );
|
|
|
|
foreach( var childFi in fields )
|
|
{
|
|
string name = childFi.Name;
|
|
var dontAtt = childFi.GetCustomAttributes<lib.Dont>();
|
|
var doAtt = childFi.GetCustomAttributes<lib.Do>();
|
|
|
|
string propName = "";
|
|
if( name.StartsWith( "<" ) && name.EndsWith( "BackingField" ) )
|
|
{
|
|
var gtIndex = name.IndexOf( '>' );
|
|
|
|
propName = name.Substring( 1, gtIndex - 1 );
|
|
|
|
var propInfo = narrowType.GetProperty( propName );
|
|
|
|
dontAtt = propInfo.GetCustomAttributes<lib.Dont>();
|
|
doAtt = propInfo.GetCustomAttributes<lib.Do>();
|
|
}
|
|
|
|
|
|
if( dontAtt.Any() )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if( isImm )
|
|
{
|
|
if( name == "MetaStorage" ) continue;
|
|
if( name == "Fn" ) continue;
|
|
}
|
|
|
|
if( !doAtt.Any() && FilterField( filterFields, doImpls, whitelistFields, childFi as MemberInfo, name ) )
|
|
continue;
|
|
|
|
object[] objs = childFi.GetCustomAttributes( typeof( NonSerializedAttribute ), true );
|
|
|
|
if( objs.Length > 0 )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//if( childFi.GetCustomAttribute<WhitelistAttribute>() )
|
|
|
|
name = refl.TypeToIdentifier( name );
|
|
|
|
var finalName = ( _cfg.Naming == BackingFieldNaming.Short && !string.IsNullOrEmpty( propName ) ) ?
|
|
propName :
|
|
name;
|
|
|
|
Serialize( writer, childFi, childFi.FieldType, childFi.GetValue( root ), finalName, depth + 1, false );
|
|
}
|
|
}
|
|
|
|
if( doProps || doImpls )
|
|
{
|
|
var props = refl.GetAllProperties( narrowType );
|
|
|
|
foreach( var childPi in props )
|
|
{
|
|
string name = childPi.Name;
|
|
|
|
var dontAtt = childPi.GetCustomAttributes<lib.Dont>();
|
|
if( dontAtt.Any() )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if( isImm )
|
|
{
|
|
if( name == "MetaStorage" ) continue;
|
|
if( name == "Fn" ) continue;
|
|
}
|
|
|
|
if( FilterField( filterProps, doImpls, whitelistProps, childPi as MemberInfo, name ) )
|
|
continue;
|
|
|
|
object[] objs = childPi.GetCustomAttributes( typeof( NonSerializedAttribute ), true );
|
|
|
|
if( objs.Length > 0 )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
name = refl.TypeToIdentifier( name );
|
|
|
|
Serialize( writer, childPi, childPi.PropertyType, childPi.GetValue( root ), name, depth + 1, false );
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
private static void GetFilters( Types TypesDefault, MemberInfo mi, Type type, out bool filterFields, out bool filterProps, out bool doImpls, out bool doFields, out bool doProps, out HashSet<string> whitelistFields, out HashSet<string> whitelistProps )
|
|
{
|
|
var custWLFields = mi?.GetCustomAttribute<ChildFieldsAttribute>( true );
|
|
var custWLProps = mi?.GetCustomAttribute<ChildPropsAttribute>( true );
|
|
|
|
filterFields = custWLFields != null;
|
|
filterProps = custWLProps != null;
|
|
|
|
var typesTodo = type.GetCustomAttribute<Ser>( true )?.Types ?? TypesDefault;
|
|
|
|
doImpls = typesTodo.HasFlag( Types.Implied );
|
|
doFields = filterFields || typesTodo.HasFlag( Types.Fields );
|
|
doProps = filterProps || typesTodo.HasFlag( Types.Props );
|
|
whitelistFields = new( custWLFields?.Values ?? new string[0] );
|
|
whitelistProps = new( custWLProps?.Values ?? new string[0] );
|
|
}
|
|
|
|
private void SerializeArray( XmlWriter writer, MemberInfo mi, Type mType, object root, int depth )
|
|
{
|
|
Array arr = (Array)root;
|
|
|
|
Type typeElem = arr.GetType().GetElementType();
|
|
|
|
Type type = root.GetType();
|
|
|
|
Type typeOfMember = typeof( object );
|
|
if( mi is FieldInfo fi ) typeOfMember = fi.FieldType;
|
|
if( mi is PropertyInfo pi ) typeOfMember = pi.PropertyType;
|
|
if( typeOfMember != type )
|
|
{
|
|
log.info( $"SerArr {typeOfMember.FriendlyName()} {mi?.Name} != {type.FriendlyName()}" );
|
|
writer.WriteAttributeString( "_.t", getTypeName( type ) );
|
|
}
|
|
|
|
bool first;
|
|
|
|
long refInt = m_objectID.GetId( root, out first );
|
|
|
|
if( _cfg.datastructure == Datastructure.Graph )
|
|
{
|
|
writer.WriteAttributeString( "ref", refInt.ToString() );
|
|
}
|
|
|
|
if( first )
|
|
{
|
|
if( _cfg.datastructure == Datastructure.Graph )
|
|
{
|
|
m_alreadySerialized[refInt] = root;
|
|
}
|
|
|
|
//typeElem.MemberType
|
|
|
|
for( int i = 0; i < arr.Length; ++i )
|
|
{
|
|
Serialize( writer, mi, typeElem, arr.GetValue( i ), "i" + i.ToString(), depth + 1, false );
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
}
|