|
public ReadContentAs ( |
||
| returnType | ||
| namespaceResolver | IXmlNamespaceResolver | |
| return | object | |
public void ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToContent();
Url = reader.GetAttribute("Url");
ServiceName = reader.GetAttribute("ServiceName");
Boolean isEmptyElement = reader.IsEmptyElement; // (1)
reader.ReadStartElement();
if (!isEmptyElement) // (1)
{
HostedServiceProperties = reader.ReadContentAs(typeof(AzureHostedServiceProperties), null) as AzureHostedServiceProperties;
reader.ReadEndElement();
}
isEmptyElement = reader.IsEmptyElement; // (1)
reader.ReadStartElement();
if (!isEmptyElement) // (1)
{
Deployments = reader.ReadContentAs(typeof(List <AzureDeployment>), null) as List <AzureDeployment>;
reader.ReadEndElement();
}
}
private static object DeserializePrimitive(XmlReader xmlReader, Type type)
{
if (!xmlReader.IsEmptyElement)
{
var name = xmlReader.Name;
xmlReader.Read();
object value = null;
if (xmlReader.NodeType == XmlNodeType.CDATA)
{
value = xmlReader.Value;
xmlReader.Read();
}
else if (xmlReader.NodeType == XmlNodeType.Text)
{
if (name == F_NUM)
{
var @float = xmlReader.ReadContentAsFloat();
value = Convert.ChangeType(@float, type);
}
else
{
value = xmlReader.ReadContentAs(type, null);
if (value is string)
{
string valueString = (string)value;
valueString = valueString.Trim();
// for some reason the cdata check above doesn't appear to work
if (valueString.StartsWith("<![CDATA[") && valueString.EndsWith("]]>"))
{
value = valueString.Substring(9, valueString.Length - 12);
}
}
}
}
xmlReader.ReadEndElement();
return value;
}
if (type == typeof (bool))
{
var value = xmlReader.Name;
bool result;
xmlReader.Read();
if (bool.TryParse(value, out result))
{
return result;
}
}
return null;
}
public override object ReadContentAs(Type returnType, IXmlNamespaceResolver namespaceResolver)
{
CheckAsync();
return(_coreReader.ReadContentAs(returnType, namespaceResolver));
}
protected void InternalReadXml(XmlReader r)
{
string containingElementType = "";
MemberInfo[] fields = GetType().GetMembers(BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic);
bool skipCloseElement = false;
foreach (MemberInfo f in fields)
{
var mInfo = Globs.GetAttr<MarshalAsAttribute>(f);
var elementType = Globs.GetMemberType(f);
string elementName = f.Name.TrimStart(new[] { '_' });
if (r.HasAttributes)
{
containingElementType = r.GetAttribute("type");
}
r.ReadStartElement(elementName);
string s;
Object val;
switch (mInfo.MarshType)
{
case MarshalType.UnionSelector:
s = r.ReadContentAsString();
// ReSharper disable once AssignNullToNotNullAttribute
val = Enum.Parse(elementType, s);
Globs.SetMember(f, this, val);
break;
case MarshalType.ArrayCount:
int intVal = r.ReadContentAsInt();
// ReSharper disable once AssignNullToNotNullAttribute
val = Convert.ChangeType(intVal, elementType);
Globs.SetMember(f, this, val);
break;
case MarshalType.Normal:
// ReSharper disable once PossibleNullReferenceException
if (elementType.GetTypeInfo().IsSubclassOf(typeof(TpmStructureBase)))
{
val = Activator.CreateInstance(elementType);
Globs.SetMember(f, this, val);
((TpmStructureBase)val).InternalReadXml(r);
break;
}
// ReSharper disable once RedundantIfElseBlock
else
{
if(elementType.TypeIsEnum())
{
s = r.ReadContentAsString();
val = Enum.Parse(elementType, s);
Globs.SetMember(f, this, val);
break;
}
if (elementType == typeof(uint) || elementType == typeof(ushort) || elementType == typeof(byte))
{
// TODO: This should be unsigned
long longVal = r.ReadContentAsLong();
val = Convert.ChangeType(longVal, elementType);
Globs.SetMember(f, this, val);
break;
}
throw new NotImplementedException("");
}
// ReSharper disable once CSharpWarnings::CS0162
// ReSharper disable once HeuristicUnreachableCode
throw new NotImplementedException("");
case MarshalType.FixedLengthArray:
case MarshalType.VariableLengthArray:
var supportedElementaryTypes = new[] { typeof(byte[]), typeof(ushort[]), typeof(uint[]) };
if (supportedElementaryTypes.Contains(elementType))
{
if (r.HasValue)
{
// ReSharper disable once AssignNullToNotNullAttribute
val = r.ReadContentAs(elementType, null);
Globs.SetMember(f, this, val);
}
else
{
// ReSharper disable once AssignNullToNotNullAttribute
Object nullObj = Activator.CreateInstance(elementType, 0x0);
Globs.SetMember(f, this, nullObj);
skipCloseElement = true;
}
break;
}
// ReSharper disable once RedundantIfElseBlock
else
{
throw new NotImplementedException("");
}
case MarshalType.Union:
// ReSharper disable once AssignNullToNotNullAttribute
val = Activator.CreateInstance(Type.GetType(containingElementType));
((TpmStructureBase)val).InternalReadXml(r);
Globs.SetMember(f, this, val);
break;
default:
throw new NotImplementedException("");
}
if (!skipCloseElement)
{
r.ReadEndElement();
}
skipCloseElement = false;
}
}
/// <summary>
/// Restores the specified part of the state of a serialised object from an XML stream.
/// </summary>
/// Members that don't have a serialised value are left untouched.
/// Unknown XML elements are reported to <see cref="AW2.Helpers.Log"/>.
/// If the deserialised object is of a type that implements <see cref="IConsistencyCheckable"/>,
/// the object is made consistent after deserialisation.
/// <param name="reader">Where to read the serialised data.</param>
/// <param name="elementName">Name of the XML element where the object is stored.</param>
/// <param name="objType">Type of the value to deserialise.</param>
/// <param name="limitationAttribute">Limit the deserialisation to members with this attribute.</param>
/// <param name="tolerant">If true, errors are not raised for missing or extra XML elements.</param>
/// <returns>The deserialised object.</returns>
public static object DeserializeXml(XmlReader reader, string elementName, Type objType, Type limitationAttribute, bool tolerant)
{
try
{
// Sanity checks
if (limitationAttribute != null &&
!typeof(Attribute).IsAssignableFrom(limitationAttribute))
throw new ArgumentException("Expected an attribute, got " + limitationAttribute.Name);
// XML consistency checks
if (!reader.IsStartElement())
throw new XmlException("Deserialisation expected start element");
if (!reader.IsStartElement(elementName))
throw new XmlException("Deserialisation expected start element " + elementName + " but got " + reader.Name);
var writtenType = GetWrittenType(reader, elementName, objType);
// Deserialise
object returnValue;
bool emptyXmlElement = reader.IsEmptyElement;
reader.Read();
if (emptyXmlElement)
returnValue = Serialization.CreateInstance(writtenType);
else if (writtenType.IsPrimitive || writtenType == typeof(string))
returnValue = reader.ReadContentAs(writtenType, null);
else if (writtenType.IsEnum)
returnValue = DeserializeXmlEnum(reader, writtenType);
else if (writtenType == typeof(Color))
returnValue = DeserializeXmlColor(reader, limitationAttribute, tolerant);
else if (writtenType == typeof(TimeSpan))
returnValue = TimeSpan.FromSeconds(reader.ReadContentAsDouble());
else if (writtenType == typeof(Curve))
returnValue = DeserializeXmlCurve(reader, limitationAttribute, tolerant);
else if (IsIEnumerable(writtenType))
returnValue = DeserializeXmlIEnumerable(reader, objType, limitationAttribute, writtenType, tolerant);
else
returnValue = DeserializeXmlOther(reader, limitationAttribute, writtenType, tolerant);
if (!emptyXmlElement)
reader.ReadEndElement();
if (writtenType != objType)
returnValue = Cast(returnValue, objType);
if (typeof(IConsistencyCheckable).IsAssignableFrom(writtenType))
((IConsistencyCheckable)returnValue).MakeConsistent(limitationAttribute);
return returnValue;
}
catch (MemberSerializationException e)
{
e.MemberName = elementName + "." + e.MemberName;
throw;
}
}
