mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-16 17:10:20 -10:00
While serializing any type into a contract member of type object an exception would be thrown. To avoid this XmlObjectSerializerWriteContext.InternalSerialize should in this case be called using the object type instead of the member type, similar how reference sources does in type instead of the member type, referencesources seems to be doing omething similar [1]. Fixes #37116. [1] http://referencesource.microsoft.com/#System.Runtime.Serialization/System/Runtime/Serialization/XmlObjectSerializerWriteContext.cs,619
625 lines
23 KiB
C#
625 lines
23 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Xml;
|
|
|
|
namespace System.Runtime.Serialization
|
|
{
|
|
internal partial class XmlFormatWriterGenerator
|
|
{
|
|
partial class CriticalHelper
|
|
{
|
|
internal XmlFormatClassWriterDelegate GenerateClassWriter(ClassDataContract classContract)
|
|
{
|
|
return (XmlWriterDelegator xw, object obj, XmlObjectSerializerWriteContext ctx, ClassDataContract ctr) => new XmlFormatWriterInterpreter (classContract).WriteToXml (xw, obj, ctx, ctr);
|
|
}
|
|
|
|
internal XmlFormatCollectionWriterDelegate GenerateCollectionWriter(CollectionDataContract collectionContract)
|
|
{
|
|
return (XmlWriterDelegator xw, object obj, XmlObjectSerializerWriteContext ctx, CollectionDataContract ctr) => new XmlFormatWriterInterpreter (collectionContract).WriteCollectionToXml (xw, obj, ctx, ctr);
|
|
}
|
|
}
|
|
}
|
|
|
|
class XmlFormatWriterInterpreter
|
|
{
|
|
public XmlFormatWriterInterpreter (ClassDataContract classContract)
|
|
{
|
|
this.classContract = classContract;
|
|
}
|
|
|
|
public XmlFormatWriterInterpreter (CollectionDataContract collectionContract)
|
|
{
|
|
this.collectionContract = collectionContract;
|
|
}
|
|
|
|
ClassDataContract classContract;
|
|
|
|
CollectionDataContract collectionContract;
|
|
|
|
XmlWriterDelegator writer = null;
|
|
object obj = null;
|
|
XmlObjectSerializerWriteContext ctx = null;
|
|
DataContract dataContract = null;
|
|
object objLocal = null;
|
|
|
|
ClassDataContract classDataContract {
|
|
get { return (ClassDataContract) dataContract; }
|
|
}
|
|
CollectionDataContract collectionDataContract {
|
|
get {return (CollectionDataContract) dataContract; }
|
|
}
|
|
|
|
XmlDictionaryString [] contractNamespaces = null;
|
|
XmlDictionaryString [] memberNames = null;
|
|
XmlDictionaryString [] childElementNamespaces = null;
|
|
int typeIndex = 1;
|
|
int childElementIndex = 0;
|
|
|
|
public void WriteToXml (XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, ClassDataContract dataContract)
|
|
{
|
|
this.writer = xmlWriter;
|
|
this.obj = obj;
|
|
this.ctx = context;
|
|
this.dataContract = dataContract;
|
|
|
|
InitArgs (classContract.UnderlyingType);
|
|
|
|
// DemandSerializationFormatterPermission (classContract) - irrelevant
|
|
// DemandMemberAccessPermission (memberAccessFlag) - irrelevant
|
|
|
|
if (classContract.IsReadOnlyContract)
|
|
{
|
|
DataContract.ThrowInvalidDataContractException (classContract.SerializationExceptionMessage, null);
|
|
}
|
|
|
|
WriteClass (classContract);
|
|
}
|
|
|
|
public void WriteCollectionToXml (XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, CollectionDataContract collectionContract)
|
|
{
|
|
this.writer = xmlWriter;
|
|
this.obj = obj;
|
|
this.ctx = context;
|
|
this.dataContract = collectionContract;
|
|
|
|
InitArgs (collectionContract.UnderlyingType);
|
|
|
|
// DemandMemberAccessPermission(memberAccessFlag);
|
|
if (collectionContract.IsReadOnlyContract)
|
|
{
|
|
DataContract.ThrowInvalidDataContractException (collectionContract.SerializationExceptionMessage, null);
|
|
}
|
|
|
|
WriteCollection (collectionContract);
|
|
}
|
|
|
|
void InitArgs (Type objType)
|
|
{
|
|
if (objType == Globals.TypeOfDateTimeOffsetAdapter) {
|
|
objLocal = DateTimeOffsetAdapter.GetDateTimeOffsetAdapter ((DateTimeOffset) obj);
|
|
}
|
|
else
|
|
objLocal = CodeInterpreter.ConvertValue (obj, typeof (object), objType);
|
|
}
|
|
|
|
void InvokeOnSerializing (ClassDataContract classContract, object objSerialized, XmlObjectSerializerWriteContext ctx)
|
|
{
|
|
if (classContract.BaseContract != null)
|
|
InvokeOnSerializing (classContract.BaseContract, objSerialized, ctx);
|
|
if (classContract.OnSerializing != null) {
|
|
classContract.OnSerializing.Invoke (objSerialized, new object [] {ctx.GetStreamingContext ()});
|
|
}
|
|
}
|
|
|
|
void InvokeOnSerialized (ClassDataContract classContract, object objSerialized, XmlObjectSerializerWriteContext ctx)
|
|
{
|
|
if (classContract.BaseContract != null)
|
|
InvokeOnSerialized (classContract.BaseContract, objSerialized, ctx);
|
|
if (classContract.OnSerialized != null) {
|
|
classContract.OnSerialized.Invoke (objSerialized, new object [] {ctx.GetStreamingContext ()});
|
|
}
|
|
}
|
|
|
|
void WriteClass (ClassDataContract classContract)
|
|
{
|
|
InvokeOnSerializing (classContract, objLocal, ctx);
|
|
|
|
if (classContract.IsISerializable)
|
|
ctx.WriteISerializable (writer, (ISerializable) objLocal);
|
|
else
|
|
{
|
|
if (classContract.ContractNamespaces.Length > 1)
|
|
contractNamespaces = classDataContract.ContractNamespaces;
|
|
memberNames = classDataContract.MemberNames;
|
|
|
|
for (int i = 0; i < classContract.ChildElementNamespaces.Length; i++)
|
|
{
|
|
if (classContract.ChildElementNamespaces[i] != null)
|
|
{
|
|
childElementNamespaces = classDataContract.ChildElementNamespaces;
|
|
}
|
|
}
|
|
|
|
if (classContract.HasExtensionData)
|
|
{
|
|
ExtensionDataObject extensionData = ((IExtensibleDataObject) objLocal).ExtensionData;
|
|
ctx.WriteExtensionData (writer, extensionData, -1);
|
|
|
|
WriteMembers (classContract, extensionData, classContract);
|
|
}
|
|
else
|
|
WriteMembers (classContract, null, classContract);
|
|
}
|
|
InvokeOnSerialized (classContract, objLocal, ctx);
|
|
}
|
|
|
|
void WriteCollection(CollectionDataContract collectionContract)
|
|
{
|
|
XmlDictionaryString itemNamespace = dataContract.Namespace;
|
|
|
|
XmlDictionaryString itemName = collectionDataContract.CollectionItemName;
|
|
|
|
if (collectionContract.ChildElementNamespace != null)
|
|
writer.WriteNamespaceDecl (collectionDataContract.ChildElementNamespace);
|
|
|
|
if (collectionContract.Kind == CollectionKind.Array)
|
|
{
|
|
Type itemType = collectionContract.ItemType;
|
|
int i;
|
|
|
|
// This check does not exist in the original dynamic code,
|
|
// but there is no other way to check type mismatch.
|
|
// CollectionSerialization.ArrayContract() shows that it is required.
|
|
if (objLocal.GetType ().GetElementType () != itemType)
|
|
throw new InvalidCastException (string.Format ("Cannot cast array of {0} to array of {1}", objLocal.GetType ().GetElementType (), itemType));
|
|
|
|
ctx.IncrementArrayCount (writer, (Array) objLocal);
|
|
|
|
if (!TryWritePrimitiveArray(collectionContract.UnderlyingType, itemType, () => objLocal, itemName, itemNamespace))
|
|
{
|
|
var arr = (Array) objLocal;
|
|
var idx = new int [1];
|
|
for (i = 0; i < arr.Length; i++) {
|
|
if (!TryWritePrimitive(itemType, null, null, i, itemNamespace, itemName, 0)) {
|
|
WriteStartElement (itemType, collectionContract.Namespace, itemNamespace, itemName, 0);
|
|
idx [0] = i;
|
|
var mbrVal = arr.GetValue (idx);
|
|
WriteValue (itemType, mbrVal, false);
|
|
WriteEndElement ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// This check does not exist in the original dynamic code,
|
|
// but there is no other way to check type mismatch.
|
|
// CollectionSerialization.ArrayContract() shows that it is required.
|
|
if (!collectionContract.UnderlyingType.IsAssignableFrom (objLocal.GetType ()))
|
|
throw new InvalidCastException (string.Format ("Cannot cast {0} to {1}", objLocal.GetType (), collectionContract.UnderlyingType));
|
|
|
|
MethodInfo incrementCollectionCountMethod = null;
|
|
switch (collectionContract.Kind)
|
|
{
|
|
case CollectionKind.Collection:
|
|
case CollectionKind.List:
|
|
case CollectionKind.Dictionary:
|
|
incrementCollectionCountMethod = XmlFormatGeneratorStatics.IncrementCollectionCountMethod;
|
|
break;
|
|
case CollectionKind.GenericCollection:
|
|
case CollectionKind.GenericList:
|
|
incrementCollectionCountMethod = XmlFormatGeneratorStatics.IncrementCollectionCountGenericMethod.MakeGenericMethod(collectionContract.ItemType);
|
|
break;
|
|
case CollectionKind.GenericDictionary:
|
|
incrementCollectionCountMethod = XmlFormatGeneratorStatics.IncrementCollectionCountGenericMethod.MakeGenericMethod(Globals.TypeOfKeyValuePair.MakeGenericType(collectionContract.ItemType.GetGenericArguments()));
|
|
break;
|
|
}
|
|
if (incrementCollectionCountMethod != null)
|
|
incrementCollectionCountMethod.Invoke (ctx, new object [] {writer, objLocal});
|
|
|
|
bool isDictionary = false, isGenericDictionary = false;
|
|
Type enumeratorType = null;
|
|
Type [] keyValueTypes = null;
|
|
if (collectionContract.Kind == CollectionKind.GenericDictionary)
|
|
{
|
|
isGenericDictionary = true;
|
|
keyValueTypes = collectionContract.ItemType.GetGenericArguments ();
|
|
enumeratorType = Globals.TypeOfGenericDictionaryEnumerator.MakeGenericType (keyValueTypes);
|
|
}
|
|
else if (collectionContract.Kind == CollectionKind.Dictionary)
|
|
{
|
|
isDictionary = true;
|
|
keyValueTypes = new Type[] { Globals.TypeOfObject, Globals.TypeOfObject };
|
|
enumeratorType = Globals.TypeOfDictionaryEnumerator;
|
|
}
|
|
else
|
|
{
|
|
enumeratorType = collectionContract.GetEnumeratorMethod.ReturnType;
|
|
}
|
|
MethodInfo moveNextMethod = enumeratorType.GetMethod (Globals.MoveNextMethodName, BindingFlags.Instance | BindingFlags.Public, null, Globals.EmptyTypeArray, null);
|
|
MethodInfo getCurrentMethod = enumeratorType.GetMethod (Globals.GetCurrentMethodName, BindingFlags.Instance | BindingFlags.Public, null, Globals.EmptyTypeArray, null);
|
|
if (moveNextMethod == null || getCurrentMethod == null)
|
|
{
|
|
if (enumeratorType.IsInterface)
|
|
{
|
|
if (moveNextMethod == null)
|
|
moveNextMethod = XmlFormatGeneratorStatics.MoveNextMethod;
|
|
if (getCurrentMethod == null)
|
|
getCurrentMethod = XmlFormatGeneratorStatics.GetCurrentMethod;
|
|
}
|
|
else
|
|
{
|
|
Type ienumeratorInterface = Globals.TypeOfIEnumerator;
|
|
CollectionKind kind = collectionContract.Kind;
|
|
if (kind == CollectionKind.GenericDictionary || kind == CollectionKind.GenericCollection || kind == CollectionKind.GenericEnumerable)
|
|
{
|
|
Type[] interfaceTypes = enumeratorType.GetInterfaces();
|
|
foreach (Type interfaceType in interfaceTypes)
|
|
{
|
|
if (interfaceType.IsGenericType
|
|
&& interfaceType.GetGenericTypeDefinition() == Globals.TypeOfIEnumeratorGeneric
|
|
&& interfaceType.GetGenericArguments()[0] == collectionContract.ItemType)
|
|
{
|
|
ienumeratorInterface = interfaceType;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (moveNextMethod == null)
|
|
moveNextMethod = CollectionDataContract.GetTargetMethodWithName(Globals.MoveNextMethodName, enumeratorType, ienumeratorInterface);
|
|
if (getCurrentMethod == null)
|
|
getCurrentMethod = CollectionDataContract.GetTargetMethodWithName(Globals.GetCurrentMethodName, enumeratorType, ienumeratorInterface);
|
|
}
|
|
}
|
|
Type elementType = getCurrentMethod.ReturnType;
|
|
object currentValue = null; // of elementType
|
|
|
|
var enumerator = (IEnumerator) collectionContract.GetEnumeratorMethod.Invoke (objLocal, new object [0]);
|
|
if (isDictionary)
|
|
{
|
|
enumerator = new CollectionDataContract.DictionaryEnumerator ((IDictionaryEnumerator) enumerator);
|
|
}
|
|
else if (isGenericDictionary)
|
|
{
|
|
Type ctorParam = Globals.TypeOfIEnumeratorGeneric.MakeGenericType(Globals.TypeOfKeyValuePair.MakeGenericType(keyValueTypes));
|
|
ConstructorInfo dictEnumCtor = enumeratorType.GetConstructor(Globals.ScanAllMembers, null, new Type[] { ctorParam }, null);
|
|
enumerator = (IEnumerator) Activator.CreateInstance (enumeratorType, new object [] {enumerator});
|
|
}
|
|
|
|
var emptyArray = new object [0];
|
|
while (enumerator != null && enumerator.MoveNext ()) {
|
|
currentValue = getCurrentMethod.Invoke (enumerator, emptyArray);
|
|
|
|
if (incrementCollectionCountMethod == null)
|
|
XmlFormatGeneratorStatics.IncrementItemCountMethod.Invoke (ctx, new object [] {1});
|
|
|
|
if (!TryWritePrimitive (elementType, () => currentValue, null, null, itemNamespace, itemName, 0))
|
|
{
|
|
WriteStartElement (elementType, collectionContract.Namespace, itemNamespace, itemName, 0);
|
|
if (isGenericDictionary || isDictionary)
|
|
collectionDataContract.ItemContract.WriteXmlValue (writer, currentValue, ctx);
|
|
else
|
|
WriteValue (elementType, currentValue, false);
|
|
WriteEndElement();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int WriteMembers (ClassDataContract classContract, ExtensionDataObject extensionData, ClassDataContract derivedMostClassContract)
|
|
{
|
|
int memberCount = (classContract.BaseContract == null) ? 0 : WriteMembers (classContract.BaseContract, extensionData, derivedMostClassContract);
|
|
|
|
XmlDictionaryString ns =
|
|
(contractNamespaces == null) ? dataContract.Namespace :
|
|
contractNamespaces [typeIndex - 1];
|
|
|
|
ctx.IncrementItemCount (classContract.Members.Count);
|
|
|
|
for (int i = 0; i < classContract.Members.Count; i++, memberCount++) {
|
|
|
|
DataMember member = classContract.Members[i];
|
|
Type memberType = member.MemberType;
|
|
object memberValue = null;
|
|
if (member.IsGetOnlyCollection)
|
|
ctx.StoreIsGetOnlyCollection ();
|
|
bool doWrite = true, hasMemberValue = false;
|
|
if (!member.EmitDefaultValue)
|
|
{
|
|
hasMemberValue = true;
|
|
memberValue = LoadMemberValue (member);
|
|
doWrite = !IsDefaultValue (memberType, memberValue);
|
|
}
|
|
|
|
if (doWrite) {
|
|
|
|
bool writeXsiType = CheckIfMemberHasConflict (member, classContract, derivedMostClassContract);
|
|
if (writeXsiType || !TryWritePrimitive (memberType, hasMemberValue ? () => memberValue : (Func<object>) null, member.MemberInfo, null /*arrayItemIndex*/, ns, null /*nameLocal*/, i + childElementIndex)) {
|
|
WriteStartElement (memberType, classContract.Namespace, ns, null /*nameLocal*/, i + childElementIndex);
|
|
if (classContract.ChildElementNamespaces [i + childElementIndex] != null)
|
|
writer.WriteNamespaceDecl (childElementNamespaces [i + childElementIndex]);
|
|
if (memberValue == null)
|
|
memberValue = LoadMemberValue (member);
|
|
WriteValue (memberType, memberValue, writeXsiType);
|
|
WriteEndElement ();
|
|
}
|
|
|
|
if (classContract.HasExtensionData)
|
|
ctx.WriteExtensionData (writer, extensionData, memberCount);
|
|
} else if (!member.EmitDefaultValue) {
|
|
if (member.IsRequired)
|
|
XmlObjectSerializerWriteContext.ThrowRequiredMemberMustBeEmitted (member.Name, classContract.UnderlyingType);
|
|
}
|
|
}
|
|
|
|
typeIndex++;
|
|
childElementIndex += classContract.Members.Count;
|
|
return memberCount;
|
|
}
|
|
|
|
|
|
internal bool IsDefaultValue (Type type, object value)
|
|
{
|
|
var def = GetDefaultValue (type);
|
|
return def == null ? (object) value == null : def.Equals (value);
|
|
}
|
|
|
|
internal object GetDefaultValue(Type type)
|
|
{
|
|
if (type.IsValueType)
|
|
{
|
|
switch (Type.GetTypeCode(type))
|
|
{
|
|
case TypeCode.Boolean:
|
|
return false;
|
|
case TypeCode.Char:
|
|
case TypeCode.SByte:
|
|
case TypeCode.Byte:
|
|
case TypeCode.Int16:
|
|
case TypeCode.UInt16:
|
|
case TypeCode.Int32:
|
|
case TypeCode.UInt32:
|
|
return 0;
|
|
case TypeCode.Int64:
|
|
case TypeCode.UInt64:
|
|
return 0L;
|
|
case TypeCode.Single:
|
|
return 0.0F;
|
|
case TypeCode.Double:
|
|
return 0.0;
|
|
case TypeCode.Decimal:
|
|
return default (decimal);
|
|
case TypeCode.DateTime:
|
|
return default (DateTime);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
bool CheckIfMemberHasConflict(DataMember member, ClassDataContract classContract, ClassDataContract derivedMostClassContract)
|
|
{
|
|
// Check for conflict with base type members
|
|
if (CheckIfConflictingMembersHaveDifferentTypes(member))
|
|
return true;
|
|
|
|
// Check for conflict with derived type members
|
|
string name = member.Name;
|
|
string ns = classContract.StableName.Namespace;
|
|
ClassDataContract currentContract = derivedMostClassContract;
|
|
while (currentContract != null && currentContract != classContract)
|
|
{
|
|
if (ns == currentContract.StableName.Namespace)
|
|
{
|
|
List<DataMember> members = currentContract.Members;
|
|
for (int j = 0; j < members.Count; j++)
|
|
{
|
|
if (name == members[j].Name)
|
|
return CheckIfConflictingMembersHaveDifferentTypes(members[j]);
|
|
}
|
|
}
|
|
currentContract = currentContract.BaseContract;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CheckIfConflictingMembersHaveDifferentTypes(DataMember member)
|
|
{
|
|
while (member.ConflictingMember != null)
|
|
{
|
|
if (member.MemberType != member.ConflictingMember.MemberType)
|
|
return true;
|
|
member = member.ConflictingMember;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool NeedsPrefix(Type type, XmlDictionaryString ns)
|
|
{
|
|
return type == Globals.TypeOfXmlQualifiedName && (ns != null && ns.Value != null && ns.Value.Length > 0);
|
|
}
|
|
|
|
void WriteStartElement (Type type, XmlDictionaryString ns, XmlDictionaryString namespaceLocal, XmlDictionaryString nameLocal, int nameIndex)
|
|
{
|
|
bool needsPrefix = NeedsPrefix(type, ns);
|
|
nameLocal = nameLocal ?? memberNames [nameIndex];
|
|
if (needsPrefix)
|
|
writer.WriteStartElement (Globals.ElementPrefix, nameLocal, namespaceLocal);
|
|
else
|
|
writer.WriteStartElement (nameLocal, namespaceLocal);
|
|
}
|
|
|
|
void WriteEndElement ()
|
|
{
|
|
writer.WriteEndElement ();
|
|
}
|
|
|
|
void WriteValue (Type memberType, object memberValue, bool writeXsiType)
|
|
{
|
|
Pointer memberValueRefPointer = null;
|
|
if (memberType.IsPointer)
|
|
memberValueRefPointer = (Pointer) XmlFormatGeneratorStatics.BoxPointer.Invoke (null, new object [] {memberValue, memberType});
|
|
bool isNullableOfT = (memberType.IsGenericType &&
|
|
memberType.GetGenericTypeDefinition() == Globals.TypeOfNullable);
|
|
if (memberType.IsValueType && !isNullableOfT)
|
|
{
|
|
PrimitiveDataContract primitiveContract = PrimitiveDataContract.GetPrimitiveDataContract(memberType);
|
|
if (primitiveContract != null && !writeXsiType)
|
|
primitiveContract.XmlFormatContentWriterMethod.Invoke (writer, new object [] {memberValue});
|
|
else {
|
|
// InternalSerialize(XmlFormatGeneratorStatics.InternalSerializeMethod, () => memberValue, memberType, writeXsiType);
|
|
var typeHandleValue = Type.GetTypeHandle (memberValue);
|
|
var isDeclaredType = typeHandleValue.Equals (CodeInterpreter.ConvertValue (memberValue, memberType, Globals.TypeOfObject));
|
|
|
|
ctx.InternalSerialize (writer, memberValue, isDeclaredType, writeXsiType, DataContract.GetId (memberType.TypeHandle), memberType.TypeHandle);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool isNull;
|
|
if (isNullableOfT)
|
|
memberValue = UnwrapNullableObject(() => memberValue, ref memberType, out isNull); //Leaves !HasValue on stack
|
|
else
|
|
isNull = memberValue == null;
|
|
if (isNull)
|
|
XmlFormatGeneratorStatics.WriteNullMethod.Invoke (ctx, new object [] {writer, memberType, DataContract.IsTypeSerializable(memberType)});
|
|
else {
|
|
PrimitiveDataContract primitiveContract = PrimitiveDataContract.GetPrimitiveDataContract(memberType);
|
|
if (primitiveContract != null && primitiveContract.UnderlyingType != Globals.TypeOfObject && !writeXsiType) {
|
|
if (isNullableOfT)
|
|
primitiveContract.XmlFormatContentWriterMethod.Invoke (writer, new object [] {memberValue});
|
|
else
|
|
primitiveContract.XmlFormatContentWriterMethod.Invoke (ctx, new object [] {writer, memberValue});
|
|
} else {
|
|
bool isNull2 = false;
|
|
if (memberType == Globals.TypeOfObject || //boxed Nullable<T>
|
|
memberType == Globals.TypeOfValueType ||
|
|
((IList)Globals.TypeOfNullable.GetInterfaces()).Contains(memberType)) {
|
|
var unwrappedMemberValue = CodeInterpreter.ConvertValue (memberValue, memberType.GetType (), Globals.TypeOfObject);
|
|
memberValue = unwrappedMemberValue;
|
|
isNull2 = memberValue == null;
|
|
}
|
|
if (isNull2) {
|
|
XmlFormatGeneratorStatics.WriteNullMethod.Invoke (ctx, new object [] {writer, memberType, DataContract.IsTypeSerializable(memberType)});
|
|
} else {
|
|
var typeHandleValue = Type.GetTypeHandle (memberValue);
|
|
var isDeclaredType = typeHandleValue.Equals (CodeInterpreter.ConvertValue (memberValue, memberType, Globals.TypeOfObject));
|
|
if (isNullableOfT) {
|
|
ctx.InternalSerialize (writer, memberValue, isDeclaredType, writeXsiType, DataContract.GetId (memberType.TypeHandle), memberType.TypeHandle);
|
|
} else if (memberType == Globals.TypeOfObject) {
|
|
var dataContract = DataContract.GetDataContract (memberValue.GetType());
|
|
writer.WriteAttributeQualifiedName (Globals.XsiPrefix, DictionaryGlobals.XsiTypeLocalName, DictionaryGlobals.SchemaInstanceNamespace, dataContract.Name, dataContract.Namespace);
|
|
ctx.InternalSerializeReference (writer, memberValue, false, false, -1, typeHandleValue);
|
|
} else {
|
|
ctx.InternalSerializeReference (writer, memberValue, isDeclaredType, writeXsiType, DataContract.GetId (memberType.TypeHandle), memberType.TypeHandle);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
object UnwrapNullableObject(Func<object> memberValue, ref Type memberType, out bool isNull)// Leaves !HasValue on stack
|
|
{
|
|
object v = memberValue ();
|
|
isNull = false;
|
|
while (memberType.IsGenericType && memberType.GetGenericTypeDefinition () == Globals.TypeOfNullable) {
|
|
Type innerType = memberType.GetGenericArguments () [0];
|
|
if ((bool) XmlFormatGeneratorStatics.GetHasValueMethod.MakeGenericMethod (innerType).Invoke (null, new object [] {v}))
|
|
v = XmlFormatGeneratorStatics.GetNullableValueMethod.MakeGenericMethod (innerType).Invoke (null, new object [] {v});
|
|
else {
|
|
isNull = true;
|
|
v = XmlFormatGeneratorStatics.GetDefaultValueMethod.MakeGenericMethod (memberType).Invoke (null, new object [0]);
|
|
}
|
|
memberType = innerType;
|
|
}
|
|
|
|
return v;
|
|
}
|
|
|
|
bool TryWritePrimitive(Type type, Func<object> value, MemberInfo memberInfo, int? arrayItemIndex, XmlDictionaryString ns, XmlDictionaryString name, int nameIndex)
|
|
{
|
|
PrimitiveDataContract primitiveContract = PrimitiveDataContract.GetPrimitiveDataContract(type);
|
|
if (primitiveContract == null || primitiveContract.UnderlyingType == Globals.TypeOfObject)
|
|
return false;
|
|
|
|
object callee = null;
|
|
var args = new List<object> ();
|
|
|
|
// load xmlwriter
|
|
if (type.IsValueType)
|
|
callee = writer;
|
|
else {
|
|
callee = ctx;
|
|
args.Add (writer);
|
|
}
|
|
// load primitive value
|
|
if (value != null)
|
|
args.Add (value ());
|
|
else if (memberInfo != null)
|
|
args.Add (CodeInterpreter.GetMember (memberInfo, objLocal));
|
|
else
|
|
args.Add (((Array) objLocal).GetValue (new int [] {(int) arrayItemIndex}));
|
|
// load name
|
|
if (name != null)
|
|
args.Add (name);
|
|
else
|
|
args.Add (memberNames [nameIndex]);
|
|
// load namespace
|
|
args.Add (ns);
|
|
// call method to write primitive
|
|
primitiveContract.XmlFormatWriterMethod.Invoke (callee, args.ToArray ());
|
|
return true;
|
|
}
|
|
|
|
bool TryWritePrimitiveArray (Type type, Type itemType, Func<object> value, XmlDictionaryString itemName, XmlDictionaryString itemNamespace)
|
|
{
|
|
PrimitiveDataContract primitiveContract = PrimitiveDataContract.GetPrimitiveDataContract(itemType);
|
|
if (primitiveContract == null)
|
|
return false;
|
|
|
|
string writeArrayMethod = null;
|
|
switch (Type.GetTypeCode(itemType))
|
|
{
|
|
case TypeCode.Boolean:
|
|
writeArrayMethod = "WriteBooleanArray";
|
|
break;
|
|
case TypeCode.DateTime:
|
|
writeArrayMethod = "WriteDateTimeArray";
|
|
break;
|
|
case TypeCode.Decimal:
|
|
writeArrayMethod = "WriteDecimalArray";
|
|
break;
|
|
case TypeCode.Int32:
|
|
writeArrayMethod = "WriteInt32Array";
|
|
break;
|
|
case TypeCode.Int64:
|
|
writeArrayMethod = "WriteInt64Array";
|
|
break;
|
|
case TypeCode.Single:
|
|
writeArrayMethod = "WriteSingleArray";
|
|
break;
|
|
case TypeCode.Double:
|
|
writeArrayMethod = "WriteDoubleArray";
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if (writeArrayMethod != null)
|
|
{
|
|
typeof (XmlWriterDelegator).GetMethod (writeArrayMethod, Globals.ScanAllMembers, null, new Type[] { type, typeof (XmlDictionaryString), typeof (XmlDictionaryString) }, null).Invoke (writer, new object [] {value (), itemName, itemNamespace});
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
object LoadMemberValue (DataMember member)
|
|
{
|
|
return CodeInterpreter.GetMember (member.MemberInfo, objLocal);
|
|
}
|
|
}
|
|
}
|