// Copyright Keysight Technologies 2012-2019
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
// License, v. 2.0. If a copy of the MPL was not distributed with this
|
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
|
using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Xml.Linq;
|
using System.Reflection;
|
using System.Globalization;
|
using System.Xml.Serialization;
|
using System.ComponentModel;
|
using System.Collections;
|
using System.Xml;
|
|
namespace OpenTap.Plugins
|
{
|
|
/// <summary>
|
/// Implemented by serializer plugins that creates and populates members of an object.
|
/// </summary>
|
public interface IConstructingSerializer
|
{
|
/// <summary> The object currently being serialized/deserialized. </summary>
|
object Object { get; }
|
/// <summary> Optionally set to indicate which member of Object is being serialized/deserialized. </summary>
|
IMemberData CurrentMember { get; }
|
}
|
/// <summary>
|
/// Default object serializer.
|
/// </summary>
|
internal class ObjectSerializer : TapSerializerPlugin, ITapSerializerPlugin, IConstructingSerializer
|
{
|
/// <summary>
|
/// Gets the member currently being serialized.
|
/// </summary>
|
public IMemberData CurrentMember { get; private set; }
|
public static XName IgnoreMemberXName = "ignore-member";
|
|
/// <summary>
|
/// Specifies order. Minimum order should be -1 as this is the most basic serializer.
|
/// </summary>
|
public override double Order
|
{
|
get { return -1; }
|
}
|
|
/// <summary> The currently serializing or deserializing object. </summary>
|
public object Object { get; private set; }
|
|
Dictionary<ITypeData, IMemberData[]> serializableMembers = new Dictionary<ITypeData, IMemberData[]>();
|
|
/// <summary>
|
/// Tries to deserialize an object from an XElement.
|
/// </summary>
|
/// <param name="element"></param>
|
/// <param name="t"></param>
|
/// <param name="setter"></param>
|
/// <param name="newobj"></param>
|
/// <param name="logWarnings">Whether warning messages should be emitted in case of missing properties.</param>
|
/// <returns>True on success.</returns>
|
public virtual bool TryDeserializeObject(XElement element, ITypeData t, Action<object> setter, object newobj = null, bool logWarnings = true)
|
{
|
|
if (element.IsEmpty && !element.HasAttributes)
|
{
|
setter(null);
|
return true;
|
}
|
if (newobj == null)
|
{
|
if (t.CanCreateInstance == false)
|
{
|
// if the instance type cannot be constructed,
|
// use the instance already on the object.
|
var objectSerializer = Serializer.SerializerStack.OfType<ObjectSerializer>().FirstOrDefault();
|
var ownerMember = objectSerializer?.CurrentMember;
|
var ownerObj = objectSerializer?.Object;
|
if (ownerMember == null || ownerObj == null)
|
{
|
throw new Exception($"Cannot create instance of {t} and no default value exists.");
|
}
|
if (ownerMember.HasAttribute<IFactoryAttribute>())
|
{
|
// Use element factory if the member type is not the target type, but rather 'has a' target type.
|
// we dont need to detect if it 'has a' target type, lets just assume it.
|
if (ownerMember.TypeDescriptor.DescendsTo(t) && ownerMember.GetAttribute<FactoryAttribute>() is FactoryAttribute f)
|
{
|
newobj = FactoryAttribute.Create(ownerObj, f);
|
}
|
else if (ownerMember.GetAttribute<ElementFactoryAttribute>() is ElementFactoryAttribute f2)
|
{
|
newobj = FactoryAttribute.Create(ownerObj, f2);
|
}
|
}
|
|
if (newobj == null)
|
{
|
newobj = ownerMember.GetValue(ownerObj);
|
if (newobj == null)
|
throw new Exception($"Unable to get default value of {ownerMember}");
|
}
|
}
|
else
|
{
|
newobj = t.CreateInstance(Array.Empty<object>());
|
}
|
}
|
|
var prevobj = Object;
|
Object = newobj;
|
|
if (newobj == null)
|
throw new ArgumentNullException(nameof(newobj));
|
t = TypeData.GetTypeData(newobj);
|
var t2 = t;
|
var properties = serializableMembers.GetOrCreateValue(t2, t3 => t3.GetMembers()
|
.Where(x => x.HasAttribute<XmlIgnoreAttribute>() == false)
|
.ToArray());
|
|
try
|
{
|
|
foreach (var prop in properties)
|
{
|
var attr = prop.GetAttribute<XmlAttributeAttribute>();
|
if (attr == null) continue;
|
var name = string.IsNullOrWhiteSpace(attr.AttributeName) ? prop.Name : attr.AttributeName;
|
var attr_value = element.Attribute(Serializer.PropertyXmlName(name));
|
|
|
if (attr_value != null)
|
{
|
try
|
{
|
var typeData = prop.TypeDescriptor.AsTypeData();
|
readContentInternal(typeData.Type, false, () => attr_value.Value, element, out object value);
|
|
prop.SetValue(newobj, value);
|
|
}
|
catch (Exception e)
|
{
|
if (logWarnings)
|
{
|
Log.Warning(element, "Attribute value '{0}' was not read correctly as a {1}", attr_value.Value, prop);
|
Log.Debug(e);
|
}
|
}
|
}
|
}
|
|
if (properties.FirstOrDefault(x => x.HasAttribute<XmlTextAttribute>()) is IMemberData mem2)
|
{
|
object value;
|
if (mem2.TypeDescriptor is TypeData td &&
|
readContentInternal(td.Load(), false, () => element.Value, element, out object _value))
|
{ value = _value; }
|
else
|
value = StringConvertProvider.FromString(element.Value, mem2.TypeDescriptor, null);
|
mem2.SetValue(newobj, value);
|
}
|
else
|
{
|
var props = properties.ToLookup(x => x.GetAttributes<XmlElementAttribute>().FirstOrDefault()?.ElementName ?? x.Name);
|
var elements = element.Elements().ToArray();
|
bool[] visited = new bool[elements.Length];
|
|
double order = 0;
|
int foundWithCurrentType = 0;
|
while (true)
|
{
|
double nextOrder = 1000;
|
// since the object might be dynamically adding properties as other props are added.
|
// we need to iterate a bit. Example: Test Plan Reference.
|
|
int found = visited.Count(x => x);
|
for (int i = 0; i < elements.Length; i++)
|
{
|
var element2 = elements[i];
|
if (visited[i]) continue;
|
if (element2.Attribute(IgnoreMemberXName) is XAttribute attr && attr.Value == "true")
|
{
|
visited[i] = true;
|
continue;
|
}
|
IMemberData property = null;
|
var name = XmlConvert.DecodeName(element2.Name.LocalName);
|
var propertyMatches = props[name];
|
|
int hits = 0;
|
foreach (var p in propertyMatches)
|
{
|
if (p.Writable || p.HasAttribute<XmlIgnoreAttribute>())
|
{
|
property = p;
|
hits++;
|
}
|
}
|
|
if (property == null)
|
{
|
continue; // later we might try this property again.
|
}
|
if (hits > 1)
|
Log.Warning(element2, "Multiple properties named '{0}' are available to the serializer in '{1}' this might give issues in serialization.", element2.Name.LocalName, t.GetAttribute<DisplayAttribute>().Name);
|
|
if (property.GetAttribute<DeserializeOrderAttribute>() is DeserializeOrderAttribute orderAttr)
|
{
|
if (order < orderAttr.Order)
|
{
|
if (orderAttr.Order < nextOrder)
|
{
|
nextOrder = orderAttr.Order;
|
}
|
continue;
|
}
|
}
|
else
|
{
|
nextOrder = order;
|
}
|
|
visited[i] = true;
|
var prev = CurrentMember;
|
CurrentMember = property;
|
try
|
{
|
if (CurrentMember.HasAttribute<XmlIgnoreAttribute>()) // This property shouldn't have been in the file in the first place, but in case it is (because of a change or a bug), we shouldn't try to set it. (E.g. SweepLoopRange.SweepStep)
|
if (!CurrentMember.HasAttribute<BrowsableAttribute>()) // In the special case we assume that this is some compatibility property that still needs to be set if present in the XML. (E.g. TestPlanReference.DynamicDataContents)
|
continue;
|
|
if (property is MemberData mem && mem.Member is PropertyInfo Property && Property.PropertyType.HasInterface<IList>() && Property.PropertyType.IsGenericType && Property.HasAttribute<XmlElementAttribute>())
|
{
|
// Special case to mimic old .NET XmlSerializer behavior
|
var list = (IList)Property.GetValue(newobj);
|
Action<object> setValue = x => list.Add(x);
|
Serializer.Deserialize(element2, setValue, Property.PropertyType.GetGenericArguments().First());
|
}
|
else
|
{
|
void setValue(object x)
|
{
|
property.SetValue(newobj, x);
|
}
|
|
if (property.HasAttribute<DeserializeInPlaceAttribute>())
|
{
|
var current = property.GetValue(newobj);
|
if (current == null)
|
throw new Exception($"Unable to deserialize {property} in-place.");
|
this.TryDeserializeObject(element2, TypeData.GetTypeData(current), (x) => { },
|
current, true);
|
}
|
else
|
{
|
Serializer.Deserialize(element2, setValue, property.TypeDescriptor);
|
}
|
}
|
}
|
catch (Exception e)
|
{
|
if (logWarnings)
|
{
|
Log.Warning(element2, "Unable to set property '{0}'.", CurrentMember.Name);
|
Log.Warning("Error was: \"{0}\".", e.Message);
|
Log.Debug(e);
|
}
|
}
|
finally
|
{
|
CurrentMember = prev;
|
}
|
}
|
|
int nowFound = visited.Count(x => x);
|
if (found == nowFound && order == nextOrder)
|
{
|
// The might have changed by loading properties.
|
var t3 = TypeData.GetTypeData(newobj);
|
if (Equals(t3, t2) == false)
|
{
|
if (nowFound != foundWithCurrentType)
|
{ // check avoids infinite loop if ITypeData did not overload Equals.
|
|
foundWithCurrentType = nowFound;
|
t2 = t3;
|
continue;
|
}
|
}
|
if (nowFound < elements.Length)
|
{ // still elements left to check. Last resort to try loading at defer.
|
|
// Some of the items might not be deserializable before defer load.
|
// if this is the case do this as a defer action.
|
void postDeserialize()
|
{
|
t2 = TypeData.GetTypeData(newobj);
|
for(int j = 0; j < elements.Length; j++)
|
{
|
if (visited[j]) continue;
|
var propertyElement = elements[j];
|
IMemberData property = null;
|
var elementName = XmlConvert.DecodeName(propertyElement.Name.LocalName);
|
try
|
{
|
property = t2.GetMember(elementName);
|
if (property == null)
|
property = t2.GetMembers().FirstOrDefault(x => x.Name == elementName);
|
}
|
catch { }
|
if (property == null || property.Writable == false)
|
{
|
continue;
|
}
|
|
Action<object> setValue = x =>
|
{
|
// Defer: this fixes an issue when `property` is ParameterMemberData,
|
// and the object being set has properties which are also deferred.
|
// This must be deferred because ParameterMemberData relies on IObjectCloner
|
// to clone the member value, but if this setter is not deferred, the objects
|
// will have been cloned before they are fully serialized
|
var priority = property is ParameterMemberData
|
? TapSerializer.DeferredLoadOrder.ParameterMemberDataSetter
|
: TapSerializer.DeferredLoadOrder.Normal;
|
Serializer.DeferLoad(() => property.SetValue(newobj, x), priority);
|
};
|
|
var prevobj2 = Object;
|
var prevmember = this.CurrentMember;
|
Object = newobj;
|
CurrentMember = property;
|
// at this point the serializer stack is technically empty,
|
// so add the current on top and deserialize.
|
Serializer.PushActiveSerializer(this);
|
try
|
{
|
Serializer.Deserialize(propertyElement, setValue, property.TypeDescriptor);
|
}
|
finally
|
{
|
// clean up.
|
Serializer.PopActiveSerializer();
|
Object = prevobj2;
|
CurrentMember = prevmember;
|
}
|
|
visited[j] = true;
|
}
|
// print a warning message if the element could not be deserialized.
|
for (int j = 0; j < elements.Length; j++)
|
{
|
if (visited[j]) continue;
|
var elem = elements[j];
|
var elementName = elem.Name.LocalName;
|
if (elementName.Contains('.') == false)
|
{
|
// if the element name contains '.' it is usually a special name and hence
|
// an error message is not needed. e.g:
|
// Package.Dependencies
|
// TestStep.Inputs
|
var message =
|
$"Unable to read element '{elem.Name.LocalName}'. The property does not exist.";
|
Serializer.PushError(elem, message);
|
}
|
}
|
}
|
Serializer.DeferLoad(postDeserialize);
|
}
|
break;
|
}
|
order = nextOrder;
|
}
|
}
|
setter(newobj);
|
}
|
finally
|
{
|
Object = prevobj;
|
|
if (newobj is IDeserializedCallback)
|
{
|
// Callback should be added in the end because an inner part of the object might also have defered it.
|
Serializer.DeferLoad(() =>
|
{
|
try
|
{
|
((IDeserializedCallback)newobj).OnDeserialized();
|
}
|
catch (Exception e)
|
{
|
Log.Warning("Exception caught while handling OnSerialized");
|
Log.Debug(e);
|
}
|
});
|
}
|
}
|
return true;
|
}
|
|
bool readContentInternal(Type propType, bool ignoreComponentSettings, Func<string> getvalueString, XElement elem, out object outvalue)
|
{
|
|
object value = null;
|
bool ok;
|
|
if (propType.IsEnum || propType.IsPrimitive || propType == typeof(string) || propType.IsValueType || propType == typeof(Type))
|
{
|
ok = true;
|
string valueString = getvalueString()?.Trim();
|
|
if (propType.IsEnum)
|
{
|
if (!string.IsNullOrEmpty(valueString))
|
{
|
// legacy support: A flagged enum did not have ','s, but just spaces between.
|
if (!valueString.Contains(','))
|
{
|
var splitted = valueString.Split(' ');
|
value = Enum.Parse(propType, string.Join(",", splitted));
|
}
|
else
|
value = Enum.Parse(propType, valueString);
|
}
|
}
|
|
else if (propType == typeof(String) || propType == typeof(char))
|
{
|
if (elem.HasElements)
|
{
|
// string contains Base64 if it has invalid XML chars.
|
// elem.Element("Base64") fails if the attribute "xmlns" is set on the document.
|
// In this case, "Base64" must be prepended with the value of xmlns in brackets.
|
// If the namespace is not set, ns.GetName("Base64") will just evaluate to "Base64"
|
var ns = elem.GetDefaultNamespace();
|
var encode = elem.Element(ns.GetName("Base64"));
|
if (encode != null)
|
{
|
try
|
{
|
value = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(encode.Value));
|
}
|
catch
|
{
|
value = encode.Value;
|
}
|
}
|
}
|
if (value == null)
|
value = valueString;
|
if (propType == typeof(char))
|
value = ((string) value)[0];
|
}
|
else if (propType == typeof(TimeSpan) || propType == typeof(TimeSpan?))
|
{
|
value = TimeSpan.Parse(valueString, CultureInfo.InvariantCulture);
|
}
|
else if (propType == typeof(Guid) || propType == typeof(Guid?))
|
{
|
value = Guid.Parse(valueString);
|
}
|
else if (propType == typeof(Type))
|
{
|
value = PluginManager.LocateType(valueString.Split(',').First());
|
}
|
else if (tryConvertNumber(propType, valueString, out value))
|
{
|
// Conversions done in tryConvertNumber
|
}
|
else if (propType.HasInterface<IConvertible>())
|
{
|
value = Convert.ChangeType(valueString, propType, CultureInfo.InvariantCulture);
|
}else if (propType.IsGenericType && propType.GetGenericTypeDefinition() == typeof(Nullable<>))
|
{
|
// For nullable<T> we recurse focusing on the underlying non-nullable type.
|
if (valueString == null)
|
{
|
outvalue = null;
|
return true; // null is a valid value for nullable types.
|
}
|
|
return readContentInternal(Nullable.GetUnderlyingType(propType), ignoreComponentSettings, getvalueString, elem, out outvalue);
|
}
|
else
|
{
|
ok = false;
|
}
|
}
|
else
|
{
|
ok = false;
|
}
|
|
outvalue = value;
|
return ok;
|
}
|
|
static bool tryConvertNumber(Type type, string valueString, out object value)
|
{
|
switch (Type.GetTypeCode(type))
|
{
|
case TypeCode.Byte:
|
{
|
byte oval;
|
bool ok = byte.TryParse(valueString, NumberStyles.Any, CultureInfo.InvariantCulture, out oval);
|
value = oval;
|
return ok;
|
}
|
case TypeCode.SByte:
|
{
|
SByte oval;
|
bool ok = SByte.TryParse(valueString, NumberStyles.Any, CultureInfo.InvariantCulture, out oval);
|
value = oval;
|
return ok;
|
}
|
case TypeCode.UInt16:
|
{
|
UInt16 oval;
|
bool ok = UInt16.TryParse(valueString, NumberStyles.Any, CultureInfo.InvariantCulture, out oval);
|
value = oval;
|
return ok;
|
}
|
case TypeCode.UInt32:
|
{
|
UInt32 oval;
|
bool ok = UInt32.TryParse(valueString, NumberStyles.Any, CultureInfo.InvariantCulture, out oval);
|
value = oval;
|
return ok;
|
}
|
case TypeCode.UInt64:
|
{
|
UInt64 oval;
|
bool ok = UInt64.TryParse(valueString, NumberStyles.Any, CultureInfo.InvariantCulture, out oval);
|
value = oval;
|
return ok;
|
}
|
|
case TypeCode.Int16:
|
{
|
Int16 oval;
|
bool ok = Int16.TryParse(valueString, NumberStyles.Any, CultureInfo.InvariantCulture, out oval);
|
value = oval;
|
return ok;
|
}
|
case TypeCode.Int32:
|
{
|
Int32 oval;
|
bool ok = Int32.TryParse(valueString, NumberStyles.Any, CultureInfo.InvariantCulture, out oval);
|
value = oval;
|
return ok;
|
}
|
case TypeCode.Int64:
|
{
|
Int64 oval;
|
bool ok = Int64.TryParse(valueString, NumberStyles.Any, CultureInfo.InvariantCulture, out oval);
|
value = oval;
|
return ok;
|
}
|
case TypeCode.Decimal:
|
{
|
value = BigFloat.Convert(valueString, CultureInfo.InvariantCulture).ConvertTo(typeof(decimal));
|
return true;
|
}
|
case TypeCode.Double:
|
{
|
Double oval;
|
bool ok = Double.TryParse(valueString, NumberStyles.Any, CultureInfo.InvariantCulture, out oval);
|
value = oval;
|
return ok;
|
}
|
case TypeCode.Single:
|
{
|
Single oval;
|
bool ok = Single.TryParse(valueString, NumberStyles.Any, CultureInfo.InvariantCulture, out oval);
|
value = oval;
|
return ok;
|
}
|
default:
|
value = null;
|
return false;
|
}
|
}
|
|
// for detecting cycles in object serialization.
|
HashSet<object> cycleDetetionSet = new HashSet<object>();
|
|
bool AlwaysG17DoubleFormat = false;
|
|
internal static readonly XName DefaultValue = "DefaultValue";
|
|
/// <summary>
|
/// Deserializes an object from XML.
|
/// </summary>
|
/// <param name="element"></param>
|
/// <param name="t"></param>
|
/// <param name="setter"></param>
|
/// <returns></returns>
|
public override bool Deserialize(XElement element, ITypeData t, Action<object> setter)
|
{
|
try
|
{
|
if (t is TypeData ctd)
|
{
|
if (readContentInternal(ctd.Type, false, () => element.IsEmpty ? null : element.Value, element, out object obj))
|
{
|
setter(obj);
|
return true;
|
}
|
}
|
if (TryDeserializeObject(element, t, setter))
|
return true;
|
}
|
catch (Exception ex)
|
{
|
Serializer.HandleError(element, $"Unable to read {t.GetDisplayAttribute().GetFullName()}.", ex);
|
}
|
return false;
|
}
|
/// <summary>
|
/// Checks if the string can be turned into an XML string.
|
/// This should return true only if the transformation to/from xml is reversible.
|
/// </summary>
|
/// <param name="str"></param>
|
/// <returns></returns>
|
static bool containsOnlyReversibleTapXmlChars(string str)
|
{
|
int len = str.Length;
|
for(int i = 0; i < len; i++)
|
{
|
char c = str[i];
|
if (c == '\r') // special case. Somehow deserialization turns \n into \r.
|
return false;
|
if (char.IsLetter(c))
|
continue;
|
if (XmlConvert.IsXmlChar(c))
|
continue;
|
if(i < len - 1)
|
{
|
char c2 = str[i + 1];
|
if(XmlConvert.IsXmlSurrogatePair(c2, c))
|
continue;
|
}
|
return false;
|
|
}
|
return true;
|
}
|
|
private List<string> GetUsedFiles(object obj)
|
{
|
var result = new List<string>();
|
|
string GetStringOrMacroString(IMemberData prop, object o)
|
{
|
if (prop.HasAttribute<XmlIgnoreAttribute>())
|
return null;
|
object val = prop.GetValue(o);
|
|
if (val is string s)
|
return s;
|
if (val is MacroString m)
|
return m.ToString();
|
|
return null;
|
}
|
|
var td = TypeData.GetTypeData(obj);
|
|
var props = td.GetMembers().Where(m => m.HasAttribute<FileDependencyAttribute>());
|
foreach (var prop in props)
|
{
|
var path = GetStringOrMacroString(prop, obj);
|
|
if (string.IsNullOrWhiteSpace(path) == false)
|
result.Add(path);
|
}
|
|
return result;
|
}
|
|
// this 'cache' only caches serialized values during this instance of the serialize
|
// this is to avoid a memory leak for e.g GUIDs, which falls into the category of primitives.
|
readonly Dictionary<object, string> enumTable = new Dictionary<object, string>();
|
|
/// <summary>
|
/// Serializes an object to XML.
|
/// </summary>
|
/// <param name="elem"></param>
|
/// <param name="obj"></param>
|
/// <param name="expectedType"></param>
|
/// <returns></returns>
|
public override bool Serialize(XElement elem, object obj, ITypeData expectedType)
|
{
|
if (obj == null)
|
return true;
|
|
object prevObj = Object;
|
// If cycleDetectorLut already contains an element, we've been here before.
|
// Note the cycleDetectorLut adds and removes the obj later if it is not already in it.
|
if (!cycleDetetionSet.Add(obj))
|
throw new Exception("Cycle detected");
|
|
foreach (var fileResource in GetUsedFiles(obj))
|
Serializer.NotifyFileUsed(fileResource);
|
|
object obj2 = obj;
|
try
|
{
|
Object = obj;
|
switch (obj)
|
{
|
case double d:
|
if (AlwaysG17DoubleFormat)
|
{
|
// the fastest and most accurate string representation of a double.
|
elem.Value = d.ToString("G17", CultureInfo.InvariantCulture);
|
return true;
|
}
|
else
|
{
|
// It was decided to use R instead of G17 for readability, although G17 is slightly faster.
|
// however, there is a bug in "R" formatting on some .NET versions, that means that
|
// roundtrip actually does not work.
|
// See section "Note to Callers:" at https://msdn.microsoft.com/en-us/library/kfsatb94(v=vs.110).aspx
|
// so here we format and then parse back to see if it can actually roundtrip.
|
// if not, we format with G17.
|
var d_str = d.ToString("R", CultureInfo.InvariantCulture);
|
var d_re = double.Parse(d_str, CultureInfo.InvariantCulture);
|
if (d_re != d)
|
// round trip not possible with R, use G17 instead.
|
d_str = d.ToString("G17", CultureInfo.InvariantCulture);
|
elem.Value = d_str;
|
|
return true;
|
}
|
case float f:
|
elem.Value = f.ToString("R", CultureInfo.InvariantCulture);
|
return true;
|
case decimal d:
|
elem.Value = BigFloat.Convert(d).ToString(CultureInfo.InvariantCulture);
|
return true;
|
case char c:
|
// Convert to a string and then handle it later.
|
obj = Convert.ToString(c, CultureInfo.InvariantCulture);
|
break;
|
}
|
|
if (obj is string str) // handled separately due to "case char c" from above.
|
{
|
// check if the str->xml is reversible otherwise base64 encode it.
|
if (containsOnlyReversibleTapXmlChars(str) && str.Trim() == str)
|
{
|
elem.Value = str;
|
}
|
else
|
{
|
var subelem = new XElement("Base64", Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(str)));
|
elem.Add(subelem);
|
}
|
return true;
|
}
|
|
if (expectedType is TypeData type)
|
{
|
if(type.Type.IsEnum || type.Type.IsPrimitive || type.Type.IsValueType)
|
{
|
if (type.Type == typeof(bool))
|
{
|
elem.Value =
|
(bool)obj ? "true" : "false"; // must be lower case for old XmlSerializer to work
|
return true;
|
}
|
|
if (enumTable.TryGetValue(obj, out var v))
|
{
|
elem.Value = v;
|
return true;
|
}
|
v = Convert.ToString(obj, CultureInfo.InvariantCulture);
|
enumTable[obj] = v;
|
elem.Value = v;
|
return true;
|
}
|
}
|
|
IMemberData xmlTextProp = null;
|
var _type = TypeData.GetTypeData(obj);
|
var properties = _type.GetMembers();
|
foreach (IMemberData prop in properties)
|
{
|
if (prop.HasAttribute<XmlIgnoreAttribute>()) continue;
|
if (prop.HasAttribute<XmlTextAttribute>())
|
xmlTextProp = prop;
|
var attr = prop.GetAttribute<XmlAttributeAttribute>();
|
if (attr != null)
|
{
|
var val = prop.GetValue(obj);
|
var defaultAttr = prop.GetAttribute<DefaultValueAttribute>();
|
var name = string.IsNullOrWhiteSpace(attr.AttributeName) ? prop.Name : attr.AttributeName;
|
if (defaultAttr != null && object.Equals(defaultAttr.Value, val))
|
continue;
|
string valStr = Convert.ToString(val, CultureInfo.InvariantCulture);
|
if (val is bool b)
|
valStr = b ? "true" : "false"; // must be lower case for old XmlSerializer to work
|
elem.SetAttributeValue(Serializer.PropertyXmlName(name), valStr);
|
}
|
}
|
|
if (xmlTextProp != null)
|
{ // XmlTextAttribute support
|
var text = xmlTextProp.GetValue(obj);
|
if (text != null)
|
Serializer.Serialize(elem, text, xmlTextProp.TypeDescriptor);
|
}
|
else
|
{
|
foreach (IMemberData subProp in properties)
|
{
|
if (subProp.HasAttribute<XmlIgnoreAttribute>()) continue;
|
if (subProp.Readable && subProp.Writable && null == subProp.GetAttribute<XmlAttributeAttribute>())
|
{
|
var oldProp = CurrentMember;
|
CurrentMember = subProp;
|
try
|
{
|
object val = subProp.GetValue(obj);
|
|
var enu = val as IEnumerable;
|
if (enu != null && enu.GetEnumerator().MoveNext() == false) // the value is an empty IEnumerable
|
{
|
var defaultAttr = subProp.GetAttribute<DefaultValueAttribute>();
|
if (defaultAttr != null && defaultAttr.Value == null)
|
continue;
|
}
|
|
var attr = subProp.GetAttribute<XmlElementAttribute>();
|
if (subProp.TypeDescriptor is TypeData cst && cst.Type.HasInterface<IList>() &&
|
cst.Type.IsGenericType && attr != null)
|
{
|
// Special case to mimic old .NET XmlSerializer behavior
|
foreach (var item in enu)
|
{
|
string name = attr.ElementName ?? subProp.Name;
|
XElement elem2 = new XElement(Serializer.PropertyXmlName(name));
|
SetHasDefaultValueAttribute(subProp, item, elem2);
|
elem.Add(elem2);
|
Serializer.Serialize(elem2, item, TypeData.FromType(cst.Type.GetGenericArguments().First()));
|
}
|
}
|
else
|
{
|
XElement elem2 = new XElement(Serializer.PropertyXmlName(subProp.Name));
|
|
{ // MetaDataAttribute -> save the metadata name in the test plan xml.
|
if (subProp.GetAttribute<MetaDataAttribute>() is MetaDataAttribute metaDataAttr)
|
{
|
string name = metaDataAttr.Name ??
|
subProp.GetDisplayAttribute()?.Name ?? subProp.Name;
|
elem2.SetAttributeValue("Metadata", name);
|
}
|
}
|
|
// if the setting has the default value, then don't notify that the type has been used,
|
// because it will probably not have been used in the end.
|
bool hasDefaultValue = SetHasDefaultValueAttribute(subProp, val, elem2);
|
|
elem.Add(elem2);
|
|
Serializer.Serialize(elem2, val, subProp.TypeDescriptor, notifyTypeUsed: !hasDefaultValue);
|
}
|
}
|
catch (Exception e)
|
{
|
Serializer.PushError(null, $"Unable to serialize property '{subProp.Name}'.", e);
|
}
|
finally
|
{
|
CurrentMember = oldProp;
|
}
|
}
|
}
|
}
|
|
if (elem.IsEmpty && obj != null)
|
elem.Value = "";
|
return true;
|
}
|
finally
|
{
|
Object = prevObj;
|
if (!cycleDetetionSet.Remove(obj2))
|
throw new InvalidOperationException("obj was modified.");
|
}
|
}
|
|
bool SetHasDefaultValueAttribute(IMemberData subProp, object val, XElement elem2)
|
{
|
|
var attr = subProp.GetAttribute<DefaultValueAttribute>();
|
if (attr != null && !(subProp is IParameterMemberData))
|
{
|
Serializer.GetSerializer<DefaultValueSerializer>().RegisterDefaultValue(elem2, attr.Value);
|
return val == attr.Value;
|
}
|
return false;
|
}
|
}
|
}
|
