private MemberSerializingSettings GetMember(TypeSerializingSettings typeSettings, string memberAlias)
{
MemberSerializingSettings ret;
bool GetMemberFromType(TypeSerializingSettings typeSettingsInternal)
{
return(typeSettingsInternal.RegisteredMembers.TryGetValue(memberAlias, out ret) ||
typeSettingsInternal.RegisteredLegacyMembers.TryGetValue(memberAlias, out ret));
}
if (GetMemberFromType(typeSettings))
{
return(ret);
}
if (!typeSettings.IncludeAncestors)
{
return(null);
}
if (typeSettings.Type.GetAncestors()
.Select(ancestor => this.SerializerModel.TryGetTypeSettings(ancestor))
.Where(ts => ts != null)
.Any(GetMemberFromType))
{
return(ret);
}
return(null);
}
public override void Deserialize(object instance, XElement xml, Type type, TypeSerializingSettings typeSettings)
{
if (xml.Elements().Any(e => !e.HasElements))
{
Console.WriteLine("WARNING [malformed XML]: Empty item entries found in collection.");
}
var elements = xml.Elements(ItemTag)
.Where(e => e.HasElements)
.Select(e => this.SerializerModel.DeserializeSubObject(e.Elements().First()));
if (instance is IList il)
{
foreach (var element in elements)
{
il.Add(element);
}
return;
}
var addMethod = type.GetAllInstanceMethods().FirstOrDefault(m => m.Name == "Add" && m.GetParameters().Length == 1);
if (addMethod == null)
{
Console.WriteLine($"WARNING: No suitable Add method found on {type}. Discarding collection content.");
return;
}
foreach (var element in elements)
{
addMethod.Invoke(instance, new[] { element });
}
}
public override void Serialize(object instance, XElement xml, Type type, TypeSerializingSettings typeSettingsr)
{
foreach (var element in (IEnumerable)instance)
{
xml.Add(new XElement(ItemTag, this.SerializerModel.SerializeSubObject(element)));
}
}
public override void Serialize(object instance, XElement xml, Type type, TypeSerializingSettings typeSettings)
{
var dict = instance as IDictionary ?? throw new Exception("Instance must implement IDictionary.");
foreach (DictionaryEntry element in dict)
{
var item = new XElement(ItemTag);
item.Add(this.SerializerModel.SerializeSubObject(element.Key));
item.Add(this.SerializerModel.SerializeSubObject(element.Value));
xml.Add(item);
}
}
public void TestBasicSerialization()
{
var serializer = new XmSerializerModel();
var settings = new TypeSerializingSettings("DTO with whitespace", typeof(PrimitivesDto));
settings.AddMember(new MemberSerializingSettings(nameof(PrimitivesDto.TestString), "testField", false));
serializer.AddType(settings);
var dto = new PrimitivesDto {
TestString = "test"
};
var result = TestSerialization(dto, serializer);
Assert.AreEqual(result.TestString, dto.TestString);
}
public override void Deserialize(object instance, XElement xml, Type type, TypeSerializingSettings typeSettings)
{
if (!(instance is IDictionary dict))
{
Console.WriteLine($"WARNING [incompatibility]: Target type {type} does not implement IDictionary. Discarding dictionary content.");
return;
}
foreach (var element in xml.Elements(ItemTag))
{
var key = this.SerializerModel.DeserializeSubObject(element.Elements().First());
var value = this.SerializerModel.DeserializeSubObject(element.Elements().Skip(1).First());
dict.Add(key, value);
}
}
private IEnumerable <MemberSerializingSettings> GetAllMembers(TypeSerializingSettings typeSettings)
{
foreach (var member in typeSettings.RegisteredMembers.Values)
{
yield return(member);
}
if (!typeSettings.IncludeAncestors)
{
yield break;
}
var ancestorMembers = typeSettings.Type.GetAncestors()
.Select(ancestor => this.SerializerModel.TryGetTypeSettings(ancestor))
.Where(ts => ts != null)
.SelectMany(type => type.RegisteredMembers.Values);
foreach (var member in ancestorMembers)
{
yield return(member);
}
}
public CollectionSerializer(XmSerializerModel serializerModel) : base(serializerModel)
{
serializerModel.AddType(new TypeSerializingSettings(typeof(List <>))
{
IsCollection = true, SkipConstructor = false
});
serializerModel.AddType(new TypeSerializingSettings(typeof(Collection <>))
{
IsCollection = true, SkipConstructor = false
});
serializerModel.AddType(new TypeSerializingSettings(typeof(ArrayList))
{
IsCollection = true, SkipConstructor = false
});
serializerModel.AddType(new TypeSerializingSettings(typeof(SortedSet <>))
{
IsCollection = true, SkipConstructor = false
});
serializerModel.AddType(new TypeSerializingSettings(typeof(IList)));
serializerModel.AddType(new TypeSerializingSettings(typeof(IList <>)));
serializerModel.AddType(new TypeSerializingSettings(typeof(IEnumerable)));
serializerModel.AddType(new TypeSerializingSettings(typeof(IEnumerable <>)));
serializerModel.AddType(new TypeSerializingSettings(typeof(IReadOnlyList <>)));
serializerModel.AddType(new TypeSerializingSettings(typeof(IReadOnlyCollection <>)));
serializerModel.AddType(new TypeSerializingSettings(typeof(ICollection)));
serializerModel.AddType(new TypeSerializingSettings(typeof(ICollection <>)));
serializerModel.AddType(new TypeSerializingSettings(typeof(ISet <>)));
var type = new TypeSerializingSettings(typeof(ReadOnlyCollection <>));
type.AddMember(new MemberSerializingSettings("list", "InternalList", false));
serializerModel.AddType(type);
type = new TypeSerializingSettings(typeof(ReadOnlyObservableCollection <>));
type.AddMember(new MemberSerializingSettings("list", "InternalList", false));
serializerModel.AddType(type);
}
public override void Serialize(object instance, XElement xml, Type type, TypeSerializingSettings typeSettings)
{
foreach (var member in this.GetAllMembers(typeSettings).Where(m => m.Serialize).OrderBy(m => m.Alias))
{
if (!instance.TryGetMemberValue <object>(member.MemberName, member.IsProperty, out var value))
{
throw new Exception($"Member {member.Alias} not found on type {type}");
}
var content = this.SerializerModel.SerializeSubObject(value);
var memberXml = new XElement(PropertyTag);
memberXml.SetAttributeValue(NameTag, member.Alias);
memberXml.Add(content);
if (member.Obfuscate)
{
var contentString = memberXml.ToString();
var data = Encoding.UTF8.GetBytes(contentString);
for (var i = 0; i < data.Length; i++)
{
data[i] = (byte)(data[i] ^ ObfuscateByte);
}
var obfuscatedString = Convert.ToBase64String(data);
var obfuscatedXml = new XElement(ObfuscatedTag);
obfuscatedXml.SetAttributeValue(ContentTag, obfuscatedString);
xml.Add(obfuscatedXml);
}
else
{
xml.Add(memberXml);
}
}
}
public override bool CanSerialize(TypeSerializingSettings typeSettings)
{
return(typeSettings.IsDictionary);
}
public abstract void Serialize(object instance, XElement xml, Type type, TypeSerializingSettings typeSettings);
public override bool CanSerialize(TypeSerializingSettings typeSettings)
{
return(typeSettings.IsCollection);
}
public sealed override void Serialize(object instance, XElement xml, Type type, TypeSerializingSettings typeSettings)
{
this.Serialize((T)instance, xml);
}
public sealed override bool CanSerialize(TypeSerializingSettings typeSettings)
{
return(typeof(T).IsAssignableFrom(typeSettings.Type));
}
public abstract bool CanSerialize(TypeSerializingSettings typeSettings);
public override void Deserialize(object instance, XElement xml, Type type, TypeSerializingSettings typeSettings)
{
var processedMembers = new HashSet <MemberSerializingSettings>();
var members = xml.Elements().Where(xe => xe.Name == PropertyTag || xe.Name == ObfuscatedTag).Select(
xe =>
{
if (xe.Name == PropertyTag)
{
return(xe);
}
var obfuscatedString = (string)xe.Attribute(ContentTag);
var data = Convert.FromBase64String(obfuscatedString);
for (var i = 0; i < data.Length; i++)
{
data[i] = (byte)(data[i] ^ ObfuscateByte);
}
var contentString = Encoding.UTF8.GetString(data);
return(XElement.Parse(contentString));
});
foreach (var memberXml in members)
{
var memberAlias = (string)memberXml.Attribute(NameTag);
var memberSettings = this.GetMember(typeSettings, memberAlias);
if (memberSettings?.Deserialize != true)
{
continue;
}
processedMembers.Add(memberSettings);
var objectXml = memberXml.Elements().FirstOrDefault();
if (objectXml == null)
{
continue;
}
if (!memberSettings.SkipInstantiating)
{
var value = this.SerializerModel.DeserializeSubObject(objectXml);
if (!instance.TrySetMemberValue(memberSettings.MemberName, value, memberSettings.IsProperty))
{
bool success;
try
{
var memberType1 = memberSettings.IsProperty
? type.GetInstanceProperty(memberSettings.MemberName).PropertyType
: type.GetInstanceField(memberSettings.MemberName).FieldType;
value = Convert.ChangeType(value, memberType1);
success = instance.TrySetMemberValue(memberSettings.MemberName, value, memberSettings.IsProperty);
}
catch (Exception)
{
success = false;
}
if (!success)
{
Console.WriteLine($"WARNING: Could not set value to member {memberSettings.MemberName} on type {type}.");
}
}
continue;
}
if (!instance.TryGetMemberValue <object>(memberSettings.MemberName, memberSettings.IsProperty, out var member))
{
continue;
}
var memberType = member.GetType();
var memberTypeSettings = this.SerializerModel.GetTypeSettings(memberType);
foreach (var serializer in this.SerializerModel.SharedSerializers.Where(s => s.CanSerialize(memberTypeSettings)))
{
serializer.Deserialize(member, objectXml, memberType, memberTypeSettings);
}
}
foreach (var memberSetting in this.GetAllMembers(typeSettings).Where(ms => !processedMembers.Contains(ms)))
{
if (memberSetting.DefaultValue != null)
{
instance.TrySetMemberValue(memberSetting.MemberName, memberSetting.DefaultValue, memberSetting.IsProperty);
}
else if (memberSetting.DefaultValueFunc != null)
{
instance.TrySetMemberValue(memberSetting.MemberName, memberSetting.DefaultValueFunc(), memberSetting.IsProperty);
}
}
}
public override bool CanSerialize(TypeSerializingSettings typeSettings)
{
return(this.GetAllMembers(typeSettings).Any());
}
